diff --git a/Join-Object.ps1 b/Join-Object.ps1
index 63d6dce..c493d5f 100644
--- a/Join-Object.ps1
+++ b/Join-Object.ps1
@@ -366,7 +366,7 @@ function Join-Object {
                 $ScriptRoot = '.'
             }
             if (!('MoreLinq.MoreEnumerable' -as [type])) {
-                Add-Type -Path (Resolve-Path -Path "$ScriptRoot\morelinq.*\lib\net451\MoreLinq.dll")
+                Add-Type -Path (Resolve-Path -Path "$ScriptRoot\morelinq.*\lib\netstandard2.0\MoreLinq.dll")
             }
         }
         catch {
diff --git a/morelinq.3.0.0/lib/net451/MoreLinq.dll b/morelinq.3.0.0/lib/net451/MoreLinq.dll
deleted file mode 100644
index d66ae98..0000000
Binary files a/morelinq.3.0.0/lib/net451/MoreLinq.dll and /dev/null differ
diff --git a/morelinq.3.0.0/lib/netstandard1.0/MoreLinq.dll b/morelinq.3.0.0/lib/netstandard1.0/MoreLinq.dll
deleted file mode 100644
index 7d472b7..0000000
Binary files a/morelinq.3.0.0/lib/netstandard1.0/MoreLinq.dll and /dev/null differ
diff --git a/morelinq.3.0.0/lib/netstandard2.0/MoreLinq.dll b/morelinq.3.0.0/lib/netstandard2.0/MoreLinq.dll
deleted file mode 100644
index ada40bd..0000000
Binary files a/morelinq.3.0.0/lib/netstandard2.0/MoreLinq.dll and /dev/null differ
diff --git a/morelinq.3.0.0/morelinq.3.0.0.nupkg b/morelinq.3.0.0/morelinq.3.0.0.nupkg
deleted file mode 100644
index 7aef15e..0000000
Binary files a/morelinq.3.0.0/morelinq.3.0.0.nupkg and /dev/null differ
diff --git a/morelinq.3.2.0/.signature.p7s b/morelinq.3.2.0/.signature.p7s
new file mode 100644
index 0000000..eff507c
Binary files /dev/null and b/morelinq.3.2.0/.signature.p7s differ
diff --git a/morelinq.3.2.0/COPYING.txt b/morelinq.3.2.0/COPYING.txt
new file mode 100644
index 0000000..d9efc06
--- /dev/null
+++ b/morelinq.3.2.0/COPYING.txt
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+==============================================================================
+The following notice applies to a small portion of the code:
+
+The MIT License (MIT)
+
+Copyright (c) Microsoft Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/morelinq.3.2.0/lib/net451/MoreLinq.dll b/morelinq.3.2.0/lib/net451/MoreLinq.dll
new file mode 100644
index 0000000..8a2f9ea
Binary files /dev/null and b/morelinq.3.2.0/lib/net451/MoreLinq.dll differ
diff --git a/morelinq.3.2.0/lib/net451/MoreLinq.pdb b/morelinq.3.2.0/lib/net451/MoreLinq.pdb
new file mode 100644
index 0000000..7cf4bad
Binary files /dev/null and b/morelinq.3.2.0/lib/net451/MoreLinq.pdb differ
diff --git a/morelinq.3.0.0/lib/net451/MoreLinq.xml b/morelinq.3.2.0/lib/net451/MoreLinq.xml
similarity index 90%
rename from morelinq.3.0.0/lib/net451/MoreLinq.xml
rename to morelinq.3.2.0/lib/net451/MoreLinq.xml
index 1b9a116..79de6ed 100644
--- a/morelinq.3.0.0/lib/net451/MoreLinq.xml
+++ b/morelinq.3.2.0/lib/net451/MoreLinq.xml
@@ -27,6 +27,223 @@
             This operator executes immediately.
             </remarks>
         </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``4(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},System.Func{``1,``2,``3})">
+            <summary>
+            Applies two accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``5(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},System.Func{``1,``2,``3,``4})">
+            <summary>
+            Applies three accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``6(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},System.Func{``1,``2,``3,``4,``5})">
+            <summary>
+            Applies four accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``7(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},System.Func{``1,``2,``3,``4,``5,``6})">
+            <summary>
+            Applies five accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``8(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},System.Func{``1,``2,``3,``4,``5,``6,``7})">
+            <summary>
+            Applies six accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``9(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},System.Func{``1,``2,``3,``4,``5,``6,``7,``8})">
+            <summary>
+            Applies seven accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="seed7">The seed value for the seventh accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``10(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},``8,System.Func{``8,``0,``8},System.Func{``1,``2,``3,``4,``5,``6,``7,``8,``9})">
+            <summary>
+            Applies eight accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
+            <typeparam name="TAccumulate8">The type of eighth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="seed7">The seed value for the seventh accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="seed8">The seed value for the eighth accumulator.</param>
+            <param name="accumulator8">The eighth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
         <member name="M:MoreLinq.MoreEnumerable.AggregateRight``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
             <summary>
             Applies a right-associative accumulator function over a sequence.
@@ -176,7 +393,12 @@
             <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
             <param name="source">Source sequence.</param>
             <param name="count">Count to assert.</param>
-            <param name="errorSelector">Function that returns the <see cref="T:System.Exception"/> object to throw.</param>
+            <param name="errorSelector">
+            Function that receives a comparison (a negative integer if actual
+            count is less than <paramref name="count"/> and a positive integer
+            if actual count is greater than <paramref name="count"/>) and
+            <paramref name="count"/> as arguments and which returns the
+            <see cref="T:System.Exception"/> object to throw.</param>
             <returns>
             Returns the original sequence as long it is contains the
             number of elements specified by <paramref name="count"/>.
@@ -783,7 +1005,8 @@
         <member name="M:MoreLinq.MoreEnumerable.EquiZip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -796,6 +1019,9 @@
             A sequence that contains elements of the two input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -806,17 +1032,14 @@
             "2B", "3C", "4D" in turn.
             </example>
             <remarks>
-            <para>
-            If the two input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.EquiZip``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -831,6 +1054,9 @@
             A sequence that contains elements of the three input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -842,16 +1068,14 @@
             "2Bb", "3Cc", "4Dd" in turn.
             </example>
             <remarks>
-            <para>If the three input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.EquiZip``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="T1">Type of elements in first sequence</typeparam>
             <typeparam name="T2">Type of elements in second sequence</typeparam>
@@ -868,6 +1092,9 @@
             A sequence that contains elements of the four input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -880,11 +1107,7 @@
             "2BbFalse", "3CcTrue", "4DdFalse" in turn.
             </example>
             <remarks>
-            <para>
-            If the four input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.Evaluate``1(System.Collections.Generic.IEnumerable{System.Func{``0}})">
@@ -1213,8 +1436,33 @@
             and all nested sequences for which the predicate function
             returned <c>true</c>.
             </returns>
-            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null.</exception>
-            <exception cref="T:System.ArgumentNullException"><paramref name="predicate"/> is null.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="source"/> is <c>null</c>.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="predicate"/> is <c>null</c>.</exception>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Flatten(System.Collections.IEnumerable,System.Func{System.Object,System.Collections.IEnumerable})">
+            <summary>
+            Flattens a sequence containing arbitrarily-nested sequences. An
+            additional parameter specifies a function that projects an inner
+            sequence via a property of an object.
+            </summary>
+            <param name="source">The sequence that will be flattened.</param>
+            <param name="selector">
+            A function that receives each element of the sequence as an object
+            and projects an inner sequence to be flattened. If the function
+            returns <c>null</c> then the object argument is considered a leaf
+            of the flattening process.
+            </param>
+            <returns>
+            A sequence that contains the elements of <paramref name="source"/>
+            and all nested sequences projected via the
+            <paramref name="selector"/> function.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="source"/> is <c>null</c>.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="selector"/> is <c>null</c>.</exception>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
             <summary>
@@ -2043,6 +2291,44 @@
             <remarks>This operator uses deferred execution and streams its
             results.</remarks>
         </member>
+        <member name="M:MoreLinq.MoreEnumerable.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
+            <summary>
+            Applies a key-generating function to each element of a sequence and
+            returns a sequence that contains the elements of the original
+            sequence as well its key and index inside the group of its key.
+            </summary>
+            <typeparam name="TSource">Type of the source sequence elements.</typeparam>
+            <typeparam name="TKey">Type of the projected key.</typeparam>
+            <param name="source">Source sequence.</param>
+            <param name="keySelector">
+            Function that projects the key given an element in the source sequence.</param>
+            <returns>
+            A sequence of elements paired with their index within the key-group.
+            The index is the key and the element is the value of the pair.
+            </returns>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
+            <summary>
+            Applies a key-generating function to each element of a sequence and
+            returns a sequence that contains the elements of the original
+            sequence as well its key and index inside the group of its key.
+            An additional parameter specifies a comparer to use for testing the
+            equivalence of keys.
+            </summary>
+            <typeparam name="TSource">Type of the source sequence elements.</typeparam>
+            <typeparam name="TKey">Type of the projected key.</typeparam>
+            <param name="source">Source sequence.</param>
+            <param name="keySelector">
+            Function that projects the key given an element in the source sequence.</param>
+            <param name="comparer">
+            The equality comparer to use to determine whether or not keys are
+            equal. If <c>null</c>, the default equality comparer for
+            <typeparamref name="TSource"/> is used.</param>
+            <returns>
+            A sequence of elements paired with their index within the key-group.
+            The index is the key and the element is the value of the pair.
+            </returns>
+        </member>
         <member name="M:MoreLinq.MoreEnumerable.Insert``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Int32)">
             <summary>
             Inserts the elements of a sequence into another sequence at a
@@ -2883,7 +3169,9 @@
             <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
             <param name="source">The sequence to pad.</param>
             <param name="width">The width/length below which to pad.</param>
-            <param name="paddingSelector">Function to calculate padding.</param>
+            <param name="paddingSelector">
+            Function to calculate padding given the index of the missing element.
+            </param>
             <returns>
             Returns a sequence that is at least as wide/long as the width/length
             specified by the <paramref name="width"/> parameter.
@@ -2919,11 +3207,11 @@
             </remarks>
             <example>
             <code><![CDATA[
-            int[] numbers = { 123, 456, 789 };
-            var result = numbers.Pairwise((a, b) => a + b);
+            var source = new[] { "a", "b", "c", "d" };
+            var result = source.Pairwise((a, b) => a + b);
             ]]></code>
             The <c>result</c> variable, when iterated over, will yield
-            579 and 1245, in turn.
+            "ab", "bc" and "cd", in turn.
             </example>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
@@ -3780,7 +4068,7 @@
         </member>
         <member name="M:MoreLinq.MoreEnumerable.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
             <summary>
-            Peforms a scan (inclusive prefix sum) on a sequence of elements.
+            Performs a scan (inclusive prefix sum) on a sequence of elements.
             </summary>
             <remarks>
             An inclusive prefix sum returns an equal-length sequence where the
@@ -3828,6 +4116,50 @@
             <param name="transformation">Transformation operation</param>
             <returns>The scanned sequence</returns>
         </member>
+        <member name="M:MoreLinq.MoreEnumerable.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2})">
+            <summary>
+            Applies an accumulator function over sequence element keys,
+            returning the keys along with intermediate accumulator states.
+            </summary>
+            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
+            <typeparam name="TKey">The type of the key.</typeparam>
+            <typeparam name="TState">Type of the state.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="keySelector">
+            A function that returns the key given an element.</param>
+            <param name="seedSelector">
+            A function to determine the initial value for the accumulator that is
+            invoked once per key encountered.</param>
+            <param name="accumulator">
+            An accumulator function invoked for each element.</param>
+            <returns>
+            A sequence of keys paired with intermediate accumulator states.
+            </returns>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
+            <summary>
+            Applies an accumulator function over sequence element keys,
+            returning the keys along with intermediate accumulator states. An
+            additional parameter specifies the comparer to use to compare keys.
+            </summary>
+            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
+            <typeparam name="TKey">The type of the key.</typeparam>
+            <typeparam name="TState">Type of the state.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="keySelector">
+            A function that returns the key given an element.</param>
+            <param name="seedSelector">
+            A function to determine the initial value for the accumulator that is
+            invoked once per key encountered.</param>
+            <param name="accumulator">
+            An accumulator function invoked for each element.</param>
+            <param name="comparer">The equality comparer to use to determine
+            whether or not keys are equal. If <c>null</c>, the default equality
+            comparer for <typeparamref name="TSource"/> is used.</param>
+            <returns>
+            A sequence of keys paired with intermediate accumulator states.
+            </returns>
+        </member>
         <member name="M:MoreLinq.MoreEnumerable.ScanRight``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
             <summary>
             Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
@@ -5394,7 +5726,10 @@
         <member name="M:MoreLinq.MoreEnumerable.ZipLongest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -5417,19 +5752,16 @@
             "2B", "3C", "0D" in turn.
             </example>
             <remarks>
-            <para>
-            If the two input sequences are of different lengths then the result
-            sequence will always be as long as the longer of the two input
-            sequences. The default value of the shorter sequence element type
-            is used for padding.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.ZipLongest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -5455,20 +5787,16 @@
             "2Bb", "3Cc", "0Dd", "0e" in turn.
             </example>
             <remarks>
-            <para>
-            If the input sequences are of different lengths then the result
-            sequence will always be as long as the longest of input sequences.
-            The default value of the each shorter sequence element type is used
-            for padding. This operator uses deferred execution and streams its
-            results.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.ZipLongest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="T1">Type of elements in first sequence</typeparam>
             <typeparam name="T2">Type of elements in second sequence</typeparam>
@@ -5497,19 +5825,14 @@
             "2BbFalse", "3CcTrue", "0DdFalse", "0eTrue", "0\0False" in turn.
             </example>
             <remarks>
-            <para>
-            If the input sequences are of different lengths then the result
-            sequence will always be as long as the longest of input sequences.
-            The default value of the each shorter sequence element type is used
-            for padding.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.ZipShortest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -5531,9 +5854,10 @@
             </example>
             <remarks>
             <para>
-            If the two input sequences are of different lengths, the result
-            sequence is terminated as soon as the shortest input sequence is
-            exhausted.</para>
+            If the input sequences are of different lengths, the result sequence
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
+            </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
             </remarks>
@@ -5541,7 +5865,8 @@
         <member name="M:MoreLinq.MoreEnumerable.ZipShortest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element  from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -5568,7 +5893,8 @@
             <remarks>
             <para>
             If the input sequences are of different lengths, the result sequence
-            is terminated as soon as the shortest input sequence is exhausted.
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
             </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
@@ -5577,7 +5903,8 @@
         <member name="M:MoreLinq.MoreEnumerable.ZipShortest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -5607,103 +5934,312 @@
             <remarks>
             <para>
             If the input sequences are of different lengths, the result sequence
-            is terminated as soon as the shortest input sequence is exhausted.
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
             </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
             </remarks>
         </member>
-        <member name="T:MoreLinq.Experimental.AwaitQueryOptions">
-            <summary>
-            Represents options for a query whose results evaluate asynchronously.
-            </summary>
-        </member>
-        <member name="F:MoreLinq.Experimental.AwaitQueryOptions.Default">
-            <summary>
-            The default options used for a query whose results evaluate
-            asynchronously.
-            </summary>
-        </member>
-        <member name="P:MoreLinq.Experimental.AwaitQueryOptions.MaxConcurrency">
-            <summary>
-            Gets a positive (non-zero) integer that specifies the maximum
-            number of asynchronous operations to have in-flight concurrently
-            or <c>null</c> to mean unlimited concurrency.
-            </summary>
-        </member>
-        <member name="P:MoreLinq.Experimental.AwaitQueryOptions.Scheduler">
-            <summary>
-            Get the scheduler to be used for any workhorse task.
-            </summary>
-        </member>
-        <member name="P:MoreLinq.Experimental.AwaitQueryOptions.PreserveOrder">
+        <member name="T:MoreLinq.Experimental.ExperimentalEnumerable">
             <summary>
-            Get a Boolean that determines whether results should be ordered
-            the same as the source.
+            <para>
+            Provides a set of static methods for querying objects that
+            implement <see cref="T:System.Collections.Generic.IEnumerable`1" />.</para>
+            <para>
+            <strong>THE METHODS ARE EXPERIMENTAL. THEY MAY BE UNSTABLE AND
+            UNTESTED. THEY MAY BE REMOVED FROM A FUTURE MAJOR OR MINOR RELEASE AND
+            POSSIBLY WITHOUT NOTICE. USE THEM AT YOUR OWN RISK. THE METHODS ARE
+            PUBLISHED FOR FIELD EXPERIMENTATION TO SOLICIT FEEDBACK ON THEIR
+            UTILITY AND DESIGN/IMPLEMENTATION DEFECTS.</strong></para>
             </summary>
         </member>
-        <member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithMaxConcurrency(System.Nullable{System.Int32})">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``4(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{``1,``2,``3})">
             <summary>
-            Returns new options with the given concurrency limit.
+            Applies two accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <param name="value">
-            The maximum concurrent asynchronous operation to keep in flight.
-            Use <c>null</c> to mean unbounded concurrency.</param>
-            <returns>Options with the new setting.</returns>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
         </member>
-        <member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithScheduler(System.Threading.Tasks.TaskScheduler)">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``5(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{``1,``2,``3,``4})">
             <summary>
-            Returns new options with the given scheduler.
+            Applies three accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <param name="value">
-            The scheduler to use to for the workhorse task.</param>
-            <returns>Options with the new setting.</returns>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
         </member>
-        <member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithPreserveOrder(System.Boolean)">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``6(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{``1,``2,``3,``4,``5})">
             <summary>
-            Returns new options with the given Boolean indicating whether or
-            not the results should be returned in the order of the source.
+            Applies four accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <param name="value">
-            A Boolean where <c>true</c> means results are in source order and
-            <c>false</c> means that results can be delivered in order of
-            efficiency.</param>
-            <returns>Options with the new setting.</returns>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
         </member>
-        <member name="T:MoreLinq.Experimental.IAwaitQuery`1">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``7(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{``1,``2,``3,``4,``5,``6})">
             <summary>
-            Represents a sequence whose elements or results evaluate asynchronously.
+            Applies five accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <inheritdoc />
-            <typeparam name="T">The type of the source elements.</typeparam>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
         </member>
-        <member name="P:MoreLinq.Experimental.IAwaitQuery`1.Options">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``8(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{System.IObservable{``0},System.IObservable{``6}},System.Func{``1,``2,``3,``4,``5,``6,``7})">
             <summary>
-            The options that determine how the sequence evaluation behaves when
-            it is iterated.
+            Applies six accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
+            <typeparam name="TResult6">The type of the result of the sixth accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
         </member>
-        <member name="M:MoreLinq.Experimental.IAwaitQuery`1.WithOptions(MoreLinq.Experimental.AwaitQueryOptions)">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``9(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{System.IObservable{``0},System.IObservable{``6}},System.Func{System.IObservable{``0},System.IObservable{``7}},System.Func{``1,``2,``3,``4,``5,``6,``7,``8})">
             <summary>
-            Returns a new query that will use the given options.
+            Applies seven accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <param name="options">The new options to use.</param>
-            <returns>
-            Returns a new query using the supplied options.
-            </returns>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
+            <typeparam name="TResult6">The type of the result of the sixth accumulator.</typeparam>
+            <typeparam name="TResult7">The type of the result of the seventh accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
         </member>
-        <member name="T:MoreLinq.Experimental.ExperimentalEnumerable">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``10(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{System.IObservable{``0},System.IObservable{``6}},System.Func{System.IObservable{``0},System.IObservable{``7}},System.Func{System.IObservable{``0},System.IObservable{``8}},System.Func{``1,``2,``3,``4,``5,``6,``7,``8,``9})">
             <summary>
-            <para>
-            Provides a set of static methods for querying objects that
-            implement <see cref="T:System.Collections.Generic.IEnumerable`1" />.</para>
-            <para>
-            <strong>THE METHODS ARE EXPERIMENTAL. THEY MAY BE UNSTABLE AND
-            UNTESTED. THEY MAY BE REMOVED FROM A FUTURE MAJOR OR MINOR RELEASE AND
-            POSSIBLY WITHOUT NOTICE. USE THEM AT YOUR OWN RISK. THE METHODS ARE
-            PUBLISHED FOR FIELD EXPERIMENTATION TO SOLICIT FEEDBACK ON THEIR
-            UTILITY AND DESIGN/IMPLEMENTATION DEFECTS.</strong></para>
+            Applies eight accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
+            <typeparam name="TResult6">The type of the result of the sixth accumulator.</typeparam>
+            <typeparam name="TResult7">The type of the result of the seventh accumulator.</typeparam>
+            <typeparam name="TResult8">The type of the result of the eighth accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="accumulator8">The eighth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
         </member>
         <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0})">
             <summary>
@@ -5949,6 +6485,85 @@
             (though never simultaneously) may iterate over the sequence.
             </remarks>
         </member>
+        <member name="T:MoreLinq.Experimental.AwaitQueryOptions">
+            <summary>
+            Represents options for a query whose results evaluate asynchronously.
+            </summary>
+        </member>
+        <member name="F:MoreLinq.Experimental.AwaitQueryOptions.Default">
+            <summary>
+            The default options used for a query whose results evaluate
+            asynchronously.
+            </summary>
+        </member>
+        <member name="P:MoreLinq.Experimental.AwaitQueryOptions.MaxConcurrency">
+            <summary>
+            Gets a positive (non-zero) integer that specifies the maximum
+            number of asynchronous operations to have in-flight concurrently
+            or <c>null</c> to mean unlimited concurrency.
+            </summary>
+        </member>
+        <member name="P:MoreLinq.Experimental.AwaitQueryOptions.Scheduler">
+            <summary>
+            Get the scheduler to be used for any workhorse task.
+            </summary>
+        </member>
+        <member name="P:MoreLinq.Experimental.AwaitQueryOptions.PreserveOrder">
+            <summary>
+            Get a Boolean that determines whether results should be ordered
+            the same as the source.
+            </summary>
+        </member>
+        <member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithMaxConcurrency(System.Nullable{System.Int32})">
+            <summary>
+            Returns new options with the given concurrency limit.
+            </summary>
+            <param name="value">
+            The maximum concurrent asynchronous operation to keep in flight.
+            Use <c>null</c> to mean unbounded concurrency.</param>
+            <returns>Options with the new setting.</returns>
+        </member>
+        <member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithScheduler(System.Threading.Tasks.TaskScheduler)">
+            <summary>
+            Returns new options with the given scheduler.
+            </summary>
+            <param name="value">
+            The scheduler to use to for the workhorse task.</param>
+            <returns>Options with the new setting.</returns>
+        </member>
+        <member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithPreserveOrder(System.Boolean)">
+            <summary>
+            Returns new options with the given Boolean indicating whether or
+            not the results should be returned in the order of the source.
+            </summary>
+            <param name="value">
+            A Boolean where <c>true</c> means results are in source order and
+            <c>false</c> means that results can be delivered in order of
+            efficiency.</param>
+            <returns>Options with the new setting.</returns>
+        </member>
+        <member name="T:MoreLinq.Experimental.IAwaitQuery`1">
+            <summary>
+            Represents a sequence whose elements or results evaluate asynchronously.
+            </summary>
+            <inheritdoc />
+            <typeparam name="T">The type of the source elements.</typeparam>
+        </member>
+        <member name="P:MoreLinq.Experimental.IAwaitQuery`1.Options">
+            <summary>
+            The options that determine how the sequence evaluation behaves when
+            it is iterated.
+            </summary>
+        </member>
+        <member name="M:MoreLinq.Experimental.IAwaitQuery`1.WithOptions(MoreLinq.Experimental.AwaitQueryOptions)">
+            <summary>
+            Returns a new query that will use the given options.
+            </summary>
+            <param name="options">The new options to use.</param>
+            <returns>
+            Returns a new query using the supplied options.
+            </returns>
+        </member>
         <member name="T:MoreLinq.Extensions.AcquireExtension">
             <summary><c>Acquire</c> extension.</summary>
         </member>
@@ -5969,6 +6584,226 @@
             This operator executes immediately.
             </remarks>
         </member>
+        <member name="T:MoreLinq.Extensions.AggregateExtension">
+            <summary><c>Aggregate</c> extension.</summary>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``4(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},System.Func{``1,``2,``3})">
+            <summary>
+            Applies two accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``5(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},System.Func{``1,``2,``3,``4})">
+            <summary>
+            Applies three accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``6(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},System.Func{``1,``2,``3,``4,``5})">
+            <summary>
+            Applies four accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``7(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},System.Func{``1,``2,``3,``4,``5,``6})">
+            <summary>
+            Applies five accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``8(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},System.Func{``1,``2,``3,``4,``5,``6,``7})">
+            <summary>
+            Applies six accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``9(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},System.Func{``1,``2,``3,``4,``5,``6,``7,``8})">
+            <summary>
+            Applies seven accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="seed7">The seed value for the seventh accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``10(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},``8,System.Func{``8,``0,``8},System.Func{``1,``2,``3,``4,``5,``6,``7,``8,``9})">
+            <summary>
+            Applies eight accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
+            <typeparam name="TAccumulate8">The type of eighth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="seed7">The seed value for the seventh accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="seed8">The seed value for the eighth accumulator.</param>
+            <param name="accumulator8">The eighth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
         <member name="T:MoreLinq.Extensions.AggregateRightExtension">
             <summary><c>AggregateRight</c> extension.</summary>
         </member>
@@ -6120,7 +6955,12 @@
             <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
             <param name="source">Source sequence.</param>
             <param name="count">Count to assert.</param>
-            <param name="errorSelector">Function that returns the <see cref="T:System.Exception"/> object to throw.</param>
+            <param name="errorSelector">
+            Function that receives a comparison (a negative integer if actual
+            count is less than <paramref name="count"/> and a positive integer
+            if actual count is greater than <paramref name="count"/>) and
+            <paramref name="count"/> as arguments and which returns the
+            <see cref="T:System.Exception"/> object to throw.</param>
             <returns>
             Returns the original sequence as long it is contains the
             number of elements specified by <paramref name="count"/>.
@@ -6749,7 +7589,8 @@
         <member name="M:MoreLinq.Extensions.EquiZipExtension.EquiZip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -6762,6 +7603,9 @@
             A sequence that contains elements of the two input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -6772,17 +7616,14 @@
             "2B", "3C", "4D" in turn.
             </example>
             <remarks>
-            <para>
-            If the two input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.Extensions.EquiZipExtension.EquiZip``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -6797,6 +7638,9 @@
             A sequence that contains elements of the three input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -6808,16 +7652,14 @@
             "2Bb", "3Cc", "4Dd" in turn.
             </example>
             <remarks>
-            <para>If the three input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.Extensions.EquiZipExtension.EquiZip``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="T1">Type of elements in first sequence</typeparam>
             <typeparam name="T2">Type of elements in second sequence</typeparam>
@@ -6834,6 +7676,9 @@
             A sequence that contains elements of the four input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -6846,11 +7691,7 @@
             "2BbFalse", "3CcTrue", "4DdFalse" in turn.
             </example>
             <remarks>
-            <para>
-            If the four input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="T:MoreLinq.Extensions.EvaluateExtension">
@@ -7255,8 +8096,33 @@
             and all nested sequences for which the predicate function
             returned <c>true</c>.
             </returns>
-            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null.</exception>
-            <exception cref="T:System.ArgumentNullException"><paramref name="predicate"/> is null.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="source"/> is <c>null</c>.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="predicate"/> is <c>null</c>.</exception>
+        </member>
+        <member name="M:MoreLinq.Extensions.FlattenExtension.Flatten(System.Collections.IEnumerable,System.Func{System.Object,System.Collections.IEnumerable})">
+            <summary>
+            Flattens a sequence containing arbitrarily-nested sequences. An
+            additional parameter specifies a function that projects an inner
+            sequence via a property of an object.
+            </summary>
+            <param name="source">The sequence that will be flattened.</param>
+            <param name="selector">
+            A function that receives each element of the sequence as an object
+            and projects an inner sequence to be flattened. If the function
+            returns <c>null</c> then the object argument is considered a leaf
+            of the flattening process.
+            </param>
+            <returns>
+            A sequence that contains the elements of <paramref name="source"/>
+            and all nested sequences projected via the
+            <paramref name="selector"/> function.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="source"/> is <c>null</c>.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="selector"/> is <c>null</c>.</exception>
         </member>
         <member name="T:MoreLinq.Extensions.FoldExtension">
             <summary><c>Fold</c> extension.</summary>
@@ -8009,6 +8875,47 @@
             <remarks>This operator uses deferred execution and streams its
             results.</remarks>
         </member>
+        <member name="T:MoreLinq.Extensions.IndexByExtension">
+            <summary><c>IndexBy</c> extension.</summary>
+        </member>
+        <member name="M:MoreLinq.Extensions.IndexByExtension.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
+            <summary>
+            Applies a key-generating function to each element of a sequence and
+            returns a sequence that contains the elements of the original
+            sequence as well its key and index inside the group of its key.
+            </summary>
+            <typeparam name="TSource">Type of the source sequence elements.</typeparam>
+            <typeparam name="TKey">Type of the projected key.</typeparam>
+            <param name="source">Source sequence.</param>
+            <param name="keySelector">
+            Function that projects the key given an element in the source sequence.</param>
+            <returns>
+            A sequence of elements paired with their index within the key-group.
+            The index is the key and the element is the value of the pair.
+            </returns>
+        </member>
+        <member name="M:MoreLinq.Extensions.IndexByExtension.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
+            <summary>
+            Applies a key-generating function to each element of a sequence and
+            returns a sequence that contains the elements of the original
+            sequence as well its key and index inside the group of its key.
+            An additional parameter specifies a comparer to use for testing the
+            equivalence of keys.
+            </summary>
+            <typeparam name="TSource">Type of the source sequence elements.</typeparam>
+            <typeparam name="TKey">Type of the projected key.</typeparam>
+            <param name="source">Source sequence.</param>
+            <param name="keySelector">
+            Function that projects the key given an element in the source sequence.</param>
+            <param name="comparer">
+            The equality comparer to use to determine whether or not keys are
+            equal. If <c>null</c>, the default equality comparer for
+            <typeparamref name="TSource"/> is used.</param>
+            <returns>
+            A sequence of elements paired with their index within the key-group.
+            The index is the key and the element is the value of the pair.
+            </returns>
+        </member>
         <member name="T:MoreLinq.Extensions.InsertExtension">
             <summary><c>Insert</c> extension.</summary>
         </member>
@@ -8762,7 +9669,9 @@
             <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
             <param name="source">The sequence to pad.</param>
             <param name="width">The width/length below which to pad.</param>
-            <param name="paddingSelector">Function to calculate padding.</param>
+            <param name="paddingSelector">
+            Function to calculate padding given the index of the missing element.
+            </param>
             <returns>
             Returns a sequence that is at least as wide/long as the width/length
             specified by the <paramref name="width"/> parameter.
@@ -8801,11 +9710,11 @@
             </remarks>
             <example>
             <code><![CDATA[
-            int[] numbers = { 123, 456, 789 };
-            var result = numbers.Pairwise((a, b) => a + b);
+            var source = new[] { "a", "b", "c", "d" };
+            var result = source.Pairwise((a, b) => a + b);
             ]]></code>
             The <c>result</c> variable, when iterated over, will yield
-            579 and 1245, in turn.
+            "ab", "bc" and "cd", in turn.
             </example>
         </member>
         <member name="T:MoreLinq.Extensions.PartialSortExtension">
@@ -9529,7 +10438,7 @@
         </member>
         <member name="M:MoreLinq.Extensions.ScanExtension.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
             <summary>
-            Peforms a scan (inclusive prefix sum) on a sequence of elements.
+            Performs a scan (inclusive prefix sum) on a sequence of elements.
             </summary>
             <remarks>
             An inclusive prefix sum returns an equal-length sequence where the
@@ -9577,6 +10486,53 @@
             <param name="transformation">Transformation operation</param>
             <returns>The scanned sequence</returns>
         </member>
+        <member name="T:MoreLinq.Extensions.ScanByExtension">
+            <summary><c>ScanBy</c> extension.</summary>
+        </member>
+        <member name="M:MoreLinq.Extensions.ScanByExtension.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2})">
+            <summary>
+            Applies an accumulator function over sequence element keys,
+            returning the keys along with intermediate accumulator states.
+            </summary>
+            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
+            <typeparam name="TKey">The type of the key.</typeparam>
+            <typeparam name="TState">Type of the state.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="keySelector">
+            A function that returns the key given an element.</param>
+            <param name="seedSelector">
+            A function to determine the initial value for the accumulator that is
+            invoked once per key encountered.</param>
+            <param name="accumulator">
+            An accumulator function invoked for each element.</param>
+            <returns>
+            A sequence of keys paired with intermediate accumulator states.
+            </returns>
+        </member>
+        <member name="M:MoreLinq.Extensions.ScanByExtension.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
+            <summary>
+            Applies an accumulator function over sequence element keys,
+            returning the keys along with intermediate accumulator states. An
+            additional parameter specifies the comparer to use to compare keys.
+            </summary>
+            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
+            <typeparam name="TKey">The type of the key.</typeparam>
+            <typeparam name="TState">Type of the state.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="keySelector">
+            A function that returns the key given an element.</param>
+            <param name="seedSelector">
+            A function to determine the initial value for the accumulator that is
+            invoked once per key encountered.</param>
+            <param name="accumulator">
+            An accumulator function invoked for each element.</param>
+            <param name="comparer">The equality comparer to use to determine
+            whether or not keys are equal. If <c>null</c>, the default equality
+            comparer for <typeparamref name="TSource"/> is used.</param>
+            <returns>
+            A sequence of keys paired with intermediate accumulator states.
+            </returns>
+        </member>
         <member name="T:MoreLinq.Extensions.ScanRightExtension">
             <summary><c>ScanRight</c> extension.</summary>
         </member>
@@ -11062,7 +12018,10 @@
         <member name="M:MoreLinq.Extensions.ZipLongestExtension.ZipLongest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -11085,19 +12044,16 @@
             "2B", "3C", "0D" in turn.
             </example>
             <remarks>
-            <para>
-            If the two input sequences are of different lengths then the result
-            sequence will always be as long as the longer of the two input
-            sequences. The default value of the shorter sequence element type
-            is used for padding.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.Extensions.ZipLongestExtension.ZipLongest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -11123,20 +12079,16 @@
             "2Bb", "3Cc", "0Dd", "0e" in turn.
             </example>
             <remarks>
-            <para>
-            If the input sequences are of different lengths then the result
-            sequence will always be as long as the longest of input sequences.
-            The default value of the each shorter sequence element type is used
-            for padding. This operator uses deferred execution and streams its
-            results.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.Extensions.ZipLongestExtension.ZipLongest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="T1">Type of elements in first sequence</typeparam>
             <typeparam name="T2">Type of elements in second sequence</typeparam>
@@ -11165,13 +12117,7 @@
             "2BbFalse", "3CcTrue", "0DdFalse", "0eTrue", "0\0False" in turn.
             </example>
             <remarks>
-            <para>
-            If the input sequences are of different lengths then the result
-            sequence will always be as long as the longest of input sequences.
-            The default value of the each shorter sequence element type is used
-            for padding.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="T:MoreLinq.Extensions.ZipShortestExtension">
@@ -11179,8 +12125,9 @@
         </member>
         <member name="M:MoreLinq.Extensions.ZipShortestExtension.ZipShortest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -11202,9 +12149,10 @@
             </example>
             <remarks>
             <para>
-            If the two input sequences are of different lengths, the result
-            sequence is terminated as soon as the shortest input sequence is
-            exhausted.</para>
+            If the input sequences are of different lengths, the result sequence
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
+            </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
             </remarks>
@@ -11212,7 +12160,8 @@
         <member name="M:MoreLinq.Extensions.ZipShortestExtension.ZipShortest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element  from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -11239,7 +12188,8 @@
             <remarks>
             <para>
             If the input sequences are of different lengths, the result sequence
-            is terminated as soon as the shortest input sequence is exhausted.
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
             </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
@@ -11248,7 +12198,8 @@
         <member name="M:MoreLinq.Extensions.ZipShortestExtension.ZipShortest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -11278,7 +12229,8 @@
             <remarks>
             <para>
             If the input sequences are of different lengths, the result sequence
-            is terminated as soon as the shortest input sequence is exhausted.
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
             </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
@@ -11409,6 +12361,28 @@
             of an item to prepend, an item to append and the source.
             </summary>
         </member>
+        <member name="T:MoreLinq.Reactive.Observable">
+            <summary>
+            Provides a set of static methods for writing in-memory queries over observable sequences.
+            </summary>
+        </member>
+        <member name="M:MoreLinq.Reactive.Observable.Subscribe``1(System.IObservable{``0},System.Action{``0},System.Action{System.Exception},System.Action)">
+            <summary>
+            Subscribes an element handler and a completion handler to an
+            observable sequence.
+            </summary>
+            <typeparam name="T">Type of elements in <paramref name="source"/>.</typeparam>
+            <param name="source">Observable sequence to subscribe to.</param>
+            <param name="onNext">
+            Action to invoke for each element in <paramref name="source"/>.</param>
+            <param name="onError">
+            Action to invoke upon exceptional termination of the
+            <paramref name="source"/>.</param>
+            <param name="onCompleted">
+            Action to invoke upon graceful termination of <paramref name="source"/>.</param>
+            <returns>The subscription, which when disposed, will unsubscribe
+            from <paramref name="source"/>.</returns>
+        </member>
         <member name="T:MoreLinq.SequenceException">
             <summary>
             The exception that is thrown for a sequence that fails a condition.
diff --git a/morelinq.3.2.0/lib/netstandard1.0/MoreLinq.dll b/morelinq.3.2.0/lib/netstandard1.0/MoreLinq.dll
new file mode 100644
index 0000000..0641593
Binary files /dev/null and b/morelinq.3.2.0/lib/netstandard1.0/MoreLinq.dll differ
diff --git a/morelinq.3.2.0/lib/netstandard1.0/MoreLinq.pdb b/morelinq.3.2.0/lib/netstandard1.0/MoreLinq.pdb
new file mode 100644
index 0000000..467a0e1
Binary files /dev/null and b/morelinq.3.2.0/lib/netstandard1.0/MoreLinq.pdb differ
diff --git a/morelinq.3.0.0/lib/netstandard2.0/MoreLinq.xml b/morelinq.3.2.0/lib/netstandard1.0/MoreLinq.xml
similarity index 90%
rename from morelinq.3.0.0/lib/netstandard2.0/MoreLinq.xml
rename to morelinq.3.2.0/lib/netstandard1.0/MoreLinq.xml
index 1b9a116..d1fd925 100644
--- a/morelinq.3.0.0/lib/netstandard2.0/MoreLinq.xml
+++ b/morelinq.3.2.0/lib/netstandard1.0/MoreLinq.xml
@@ -27,6 +27,223 @@
             This operator executes immediately.
             </remarks>
         </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``4(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},System.Func{``1,``2,``3})">
+            <summary>
+            Applies two accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``5(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},System.Func{``1,``2,``3,``4})">
+            <summary>
+            Applies three accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``6(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},System.Func{``1,``2,``3,``4,``5})">
+            <summary>
+            Applies four accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``7(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},System.Func{``1,``2,``3,``4,``5,``6})">
+            <summary>
+            Applies five accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``8(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},System.Func{``1,``2,``3,``4,``5,``6,``7})">
+            <summary>
+            Applies six accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``9(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},System.Func{``1,``2,``3,``4,``5,``6,``7,``8})">
+            <summary>
+            Applies seven accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="seed7">The seed value for the seventh accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``10(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},``8,System.Func{``8,``0,``8},System.Func{``1,``2,``3,``4,``5,``6,``7,``8,``9})">
+            <summary>
+            Applies eight accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
+            <typeparam name="TAccumulate8">The type of eighth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="seed7">The seed value for the seventh accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="seed8">The seed value for the eighth accumulator.</param>
+            <param name="accumulator8">The eighth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
         <member name="M:MoreLinq.MoreEnumerable.AggregateRight``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
             <summary>
             Applies a right-associative accumulator function over a sequence.
@@ -176,7 +393,12 @@
             <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
             <param name="source">Source sequence.</param>
             <param name="count">Count to assert.</param>
-            <param name="errorSelector">Function that returns the <see cref="T:System.Exception"/> object to throw.</param>
+            <param name="errorSelector">
+            Function that receives a comparison (a negative integer if actual
+            count is less than <paramref name="count"/> and a positive integer
+            if actual count is greater than <paramref name="count"/>) and
+            <paramref name="count"/> as arguments and which returns the
+            <see cref="T:System.Exception"/> object to throw.</param>
             <returns>
             Returns the original sequence as long it is contains the
             number of elements specified by <paramref name="count"/>.
@@ -783,7 +1005,8 @@
         <member name="M:MoreLinq.MoreEnumerable.EquiZip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -796,6 +1019,9 @@
             A sequence that contains elements of the two input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -806,17 +1032,14 @@
             "2B", "3C", "4D" in turn.
             </example>
             <remarks>
-            <para>
-            If the two input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.EquiZip``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -831,6 +1054,9 @@
             A sequence that contains elements of the three input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -842,16 +1068,14 @@
             "2Bb", "3Cc", "4Dd" in turn.
             </example>
             <remarks>
-            <para>If the three input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.EquiZip``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="T1">Type of elements in first sequence</typeparam>
             <typeparam name="T2">Type of elements in second sequence</typeparam>
@@ -868,6 +1092,9 @@
             A sequence that contains elements of the four input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -880,11 +1107,7 @@
             "2BbFalse", "3CcTrue", "4DdFalse" in turn.
             </example>
             <remarks>
-            <para>
-            If the four input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.Evaluate``1(System.Collections.Generic.IEnumerable{System.Func{``0}})">
@@ -1213,8 +1436,33 @@
             and all nested sequences for which the predicate function
             returned <c>true</c>.
             </returns>
-            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null.</exception>
-            <exception cref="T:System.ArgumentNullException"><paramref name="predicate"/> is null.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="source"/> is <c>null</c>.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="predicate"/> is <c>null</c>.</exception>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Flatten(System.Collections.IEnumerable,System.Func{System.Object,System.Collections.IEnumerable})">
+            <summary>
+            Flattens a sequence containing arbitrarily-nested sequences. An
+            additional parameter specifies a function that projects an inner
+            sequence via a property of an object.
+            </summary>
+            <param name="source">The sequence that will be flattened.</param>
+            <param name="selector">
+            A function that receives each element of the sequence as an object
+            and projects an inner sequence to be flattened. If the function
+            returns <c>null</c> then the object argument is considered a leaf
+            of the flattening process.
+            </param>
+            <returns>
+            A sequence that contains the elements of <paramref name="source"/>
+            and all nested sequences projected via the
+            <paramref name="selector"/> function.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="source"/> is <c>null</c>.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="selector"/> is <c>null</c>.</exception>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
             <summary>
@@ -2043,6 +2291,44 @@
             <remarks>This operator uses deferred execution and streams its
             results.</remarks>
         </member>
+        <member name="M:MoreLinq.MoreEnumerable.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
+            <summary>
+            Applies a key-generating function to each element of a sequence and
+            returns a sequence that contains the elements of the original
+            sequence as well its key and index inside the group of its key.
+            </summary>
+            <typeparam name="TSource">Type of the source sequence elements.</typeparam>
+            <typeparam name="TKey">Type of the projected key.</typeparam>
+            <param name="source">Source sequence.</param>
+            <param name="keySelector">
+            Function that projects the key given an element in the source sequence.</param>
+            <returns>
+            A sequence of elements paired with their index within the key-group.
+            The index is the key and the element is the value of the pair.
+            </returns>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
+            <summary>
+            Applies a key-generating function to each element of a sequence and
+            returns a sequence that contains the elements of the original
+            sequence as well its key and index inside the group of its key.
+            An additional parameter specifies a comparer to use for testing the
+            equivalence of keys.
+            </summary>
+            <typeparam name="TSource">Type of the source sequence elements.</typeparam>
+            <typeparam name="TKey">Type of the projected key.</typeparam>
+            <param name="source">Source sequence.</param>
+            <param name="keySelector">
+            Function that projects the key given an element in the source sequence.</param>
+            <param name="comparer">
+            The equality comparer to use to determine whether or not keys are
+            equal. If <c>null</c>, the default equality comparer for
+            <typeparamref name="TSource"/> is used.</param>
+            <returns>
+            A sequence of elements paired with their index within the key-group.
+            The index is the key and the element is the value of the pair.
+            </returns>
+        </member>
         <member name="M:MoreLinq.MoreEnumerable.Insert``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Int32)">
             <summary>
             Inserts the elements of a sequence into another sequence at a
@@ -2883,7 +3169,9 @@
             <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
             <param name="source">The sequence to pad.</param>
             <param name="width">The width/length below which to pad.</param>
-            <param name="paddingSelector">Function to calculate padding.</param>
+            <param name="paddingSelector">
+            Function to calculate padding given the index of the missing element.
+            </param>
             <returns>
             Returns a sequence that is at least as wide/long as the width/length
             specified by the <paramref name="width"/> parameter.
@@ -2919,11 +3207,11 @@
             </remarks>
             <example>
             <code><![CDATA[
-            int[] numbers = { 123, 456, 789 };
-            var result = numbers.Pairwise((a, b) => a + b);
+            var source = new[] { "a", "b", "c", "d" };
+            var result = source.Pairwise((a, b) => a + b);
             ]]></code>
             The <c>result</c> variable, when iterated over, will yield
-            579 and 1245, in turn.
+            "ab", "bc" and "cd", in turn.
             </example>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
@@ -3780,7 +4068,7 @@
         </member>
         <member name="M:MoreLinq.MoreEnumerable.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
             <summary>
-            Peforms a scan (inclusive prefix sum) on a sequence of elements.
+            Performs a scan (inclusive prefix sum) on a sequence of elements.
             </summary>
             <remarks>
             An inclusive prefix sum returns an equal-length sequence where the
@@ -3828,6 +4116,50 @@
             <param name="transformation">Transformation operation</param>
             <returns>The scanned sequence</returns>
         </member>
+        <member name="M:MoreLinq.MoreEnumerable.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2})">
+            <summary>
+            Applies an accumulator function over sequence element keys,
+            returning the keys along with intermediate accumulator states.
+            </summary>
+            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
+            <typeparam name="TKey">The type of the key.</typeparam>
+            <typeparam name="TState">Type of the state.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="keySelector">
+            A function that returns the key given an element.</param>
+            <param name="seedSelector">
+            A function to determine the initial value for the accumulator that is
+            invoked once per key encountered.</param>
+            <param name="accumulator">
+            An accumulator function invoked for each element.</param>
+            <returns>
+            A sequence of keys paired with intermediate accumulator states.
+            </returns>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
+            <summary>
+            Applies an accumulator function over sequence element keys,
+            returning the keys along with intermediate accumulator states. An
+            additional parameter specifies the comparer to use to compare keys.
+            </summary>
+            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
+            <typeparam name="TKey">The type of the key.</typeparam>
+            <typeparam name="TState">Type of the state.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="keySelector">
+            A function that returns the key given an element.</param>
+            <param name="seedSelector">
+            A function to determine the initial value for the accumulator that is
+            invoked once per key encountered.</param>
+            <param name="accumulator">
+            An accumulator function invoked for each element.</param>
+            <param name="comparer">The equality comparer to use to determine
+            whether or not keys are equal. If <c>null</c>, the default equality
+            comparer for <typeparamref name="TSource"/> is used.</param>
+            <returns>
+            A sequence of keys paired with intermediate accumulator states.
+            </returns>
+        </member>
         <member name="M:MoreLinq.MoreEnumerable.ScanRight``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
             <summary>
             Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
@@ -4634,66 +4966,6 @@
             resulting array.
             </remarks>
         </member>
-        <member name="M:MoreLinq.MoreEnumerable.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1)">
-            <summary>
-            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/> object.
-            </summary>
-            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
-            <typeparam name="TTable"></typeparam>
-            <param name="source">The source.</param>
-            <param name="table"></param>
-            <returns>
-            A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
-            </returns>
-            <remarks>This operator uses immediate execution.</remarks>
-        </member>
-        <member name="M:MoreLinq.MoreEnumerable.ToDataTable``1(System.Collections.Generic.IEnumerable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
-            <summary>
-            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/>
-            object with a set of lambda expressions specifying which members (property
-            or field) of each element in the sequence will supply the column values.
-            </summary>
-            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
-            <param name="source">The source.</param>
-            <param name="expressions">Expressions providing access to element members.</param>
-            <returns>
-            A <see cref="T:System.Data.DataTable"/> representing the source.
-            </returns>
-            <remarks>This operator uses immediate execution.</remarks>
-        </member>
-        <member name="M:MoreLinq.MoreEnumerable.ToDataTable``1(System.Collections.Generic.IEnumerable{``0})">
-            <summary>
-            Converts a sequence to a <see cref="T:System.Data.DataTable"/> object.
-            </summary>
-            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
-            <param name="source">The source.</param>
-            <returns>
-            A <see cref="T:System.Data.DataTable"/> representing the source.
-            </returns>
-            <remarks>This operator uses immediate execution.</remarks>
-        </member>
-        <member name="M:MoreLinq.MoreEnumerable.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1,System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
-            <summary>
-            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/>
-            object with a set of lambda expressions specifying which members (property
-            or field) of each element in the sequence will supply the column values.
-            </summary>
-            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
-            <typeparam name="TTable">The type of the input and resulting <see cref="T:System.Data.DataTable"/> object.</typeparam>
-            <param name="source">The source.</param>
-            <param name="table">The <see cref="T:System.Data.DataTable"/> type of object where to add rows</param>
-            <param name="expressions">Expressions providing access to element members.</param>
-            <returns>
-            A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
-            </returns>
-            <remarks>This operator uses immediate execution.</remarks>
-        </member>
-        <member name="M:MoreLinq.MoreEnumerable.BuildOrBindSchema(System.Data.DataTable,System.Reflection.MemberInfo[])">
-            <remarks>
-            The resulting array may contain null entries and those represent
-            columns for which there is no source member supplying a value.
-            </remarks>
-        </member>
         <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString``1(System.Collections.Generic.IEnumerable{``0},System.String)">
             <summary>
             Creates a delimited string from a sequence of values and
@@ -5394,7 +5666,10 @@
         <member name="M:MoreLinq.MoreEnumerable.ZipLongest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -5417,19 +5692,16 @@
             "2B", "3C", "0D" in turn.
             </example>
             <remarks>
-            <para>
-            If the two input sequences are of different lengths then the result
-            sequence will always be as long as the longer of the two input
-            sequences. The default value of the shorter sequence element type
-            is used for padding.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.ZipLongest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -5455,20 +5727,16 @@
             "2Bb", "3Cc", "0Dd", "0e" in turn.
             </example>
             <remarks>
-            <para>
-            If the input sequences are of different lengths then the result
-            sequence will always be as long as the longest of input sequences.
-            The default value of the each shorter sequence element type is used
-            for padding. This operator uses deferred execution and streams its
-            results.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.ZipLongest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="T1">Type of elements in first sequence</typeparam>
             <typeparam name="T2">Type of elements in second sequence</typeparam>
@@ -5497,19 +5765,14 @@
             "2BbFalse", "3CcTrue", "0DdFalse", "0eTrue", "0\0False" in turn.
             </example>
             <remarks>
-            <para>
-            If the input sequences are of different lengths then the result
-            sequence will always be as long as the longest of input sequences.
-            The default value of the each shorter sequence element type is used
-            for padding.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.ZipShortest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -5531,9 +5794,10 @@
             </example>
             <remarks>
             <para>
-            If the two input sequences are of different lengths, the result
-            sequence is terminated as soon as the shortest input sequence is
-            exhausted.</para>
+            If the input sequences are of different lengths, the result sequence
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
+            </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
             </remarks>
@@ -5541,7 +5805,8 @@
         <member name="M:MoreLinq.MoreEnumerable.ZipShortest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element  from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -5568,7 +5833,8 @@
             <remarks>
             <para>
             If the input sequences are of different lengths, the result sequence
-            is terminated as soon as the shortest input sequence is exhausted.
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
             </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
@@ -5577,7 +5843,8 @@
         <member name="M:MoreLinq.MoreEnumerable.ZipShortest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -5607,91 +5874,13 @@
             <remarks>
             <para>
             If the input sequences are of different lengths, the result sequence
-            is terminated as soon as the shortest input sequence is exhausted.
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
             </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
             </remarks>
         </member>
-        <member name="T:MoreLinq.Experimental.AwaitQueryOptions">
-            <summary>
-            Represents options for a query whose results evaluate asynchronously.
-            </summary>
-        </member>
-        <member name="F:MoreLinq.Experimental.AwaitQueryOptions.Default">
-            <summary>
-            The default options used for a query whose results evaluate
-            asynchronously.
-            </summary>
-        </member>
-        <member name="P:MoreLinq.Experimental.AwaitQueryOptions.MaxConcurrency">
-            <summary>
-            Gets a positive (non-zero) integer that specifies the maximum
-            number of asynchronous operations to have in-flight concurrently
-            or <c>null</c> to mean unlimited concurrency.
-            </summary>
-        </member>
-        <member name="P:MoreLinq.Experimental.AwaitQueryOptions.Scheduler">
-            <summary>
-            Get the scheduler to be used for any workhorse task.
-            </summary>
-        </member>
-        <member name="P:MoreLinq.Experimental.AwaitQueryOptions.PreserveOrder">
-            <summary>
-            Get a Boolean that determines whether results should be ordered
-            the same as the source.
-            </summary>
-        </member>
-        <member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithMaxConcurrency(System.Nullable{System.Int32})">
-            <summary>
-            Returns new options with the given concurrency limit.
-            </summary>
-            <param name="value">
-            The maximum concurrent asynchronous operation to keep in flight.
-            Use <c>null</c> to mean unbounded concurrency.</param>
-            <returns>Options with the new setting.</returns>
-        </member>
-        <member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithScheduler(System.Threading.Tasks.TaskScheduler)">
-            <summary>
-            Returns new options with the given scheduler.
-            </summary>
-            <param name="value">
-            The scheduler to use to for the workhorse task.</param>
-            <returns>Options with the new setting.</returns>
-        </member>
-        <member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithPreserveOrder(System.Boolean)">
-            <summary>
-            Returns new options with the given Boolean indicating whether or
-            not the results should be returned in the order of the source.
-            </summary>
-            <param name="value">
-            A Boolean where <c>true</c> means results are in source order and
-            <c>false</c> means that results can be delivered in order of
-            efficiency.</param>
-            <returns>Options with the new setting.</returns>
-        </member>
-        <member name="T:MoreLinq.Experimental.IAwaitQuery`1">
-            <summary>
-            Represents a sequence whose elements or results evaluate asynchronously.
-            </summary>
-            <inheritdoc />
-            <typeparam name="T">The type of the source elements.</typeparam>
-        </member>
-        <member name="P:MoreLinq.Experimental.IAwaitQuery`1.Options">
-            <summary>
-            The options that determine how the sequence evaluation behaves when
-            it is iterated.
-            </summary>
-        </member>
-        <member name="M:MoreLinq.Experimental.IAwaitQuery`1.WithOptions(MoreLinq.Experimental.AwaitQueryOptions)">
-            <summary>
-            Returns a new query that will use the given options.
-            </summary>
-            <param name="options">The new options to use.</param>
-            <returns>
-            Returns a new query using the supplied options.
-            </returns>
-        </member>
         <member name="T:MoreLinq.Experimental.ExperimentalEnumerable">
             <summary>
             <para>
@@ -5705,223 +5894,290 @@
             UTILITY AND DESIGN/IMPLEMENTATION DEFECTS.</strong></para>
             </summary>
         </member>
-        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0})">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``4(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{``1,``2,``3})">
             <summary>
-            Converts a query whose results evaluate asynchronously to use
-            sequential instead of concurrent evaluation.
+            Applies two accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <typeparam name="T">The type of the source elements.</typeparam>
-            <param name="source">The source sequence.</param>
-            <returns>The converted sequence.</returns>
-        </member>
-        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32)">
-            <summary>
-            Returns a query whose results evaluate asynchronously to use a
-            concurrency limit.
-            </summary>
-            <typeparam name="T">The type of the source elements.</typeparam>
-            <param name="source">The source sequence.</param>
-            <param name="value"></param>
-            <returns>
-            A query whose results evaluate asynchronously using the given
-            concurrency limit.</returns>
-        </member>
-        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0})">
-            <summary>
-            Returns a query whose results evaluate asynchronously and
-            concurrently with no defined limitation on concurrency.
-            </summary>
-            <typeparam name="T">The type of the source elements.</typeparam>
-            <param name="source">The source sequence.</param>
-            <returns>
-            A query whose results evaluate asynchronously using no defined
-            limitation on concurrency.</returns>
-        </member>
-        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Scheduler``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Threading.Tasks.TaskScheduler)">
-            <summary>
-            Returns a query whose results evaluate asynchronously and uses the
-            given scheduler for the workhorse task.
-            </summary>
-            <typeparam name="T">The type of the source elements.</typeparam>
-            <param name="source">The source sequence.</param>
-            <param name="value">The scheduler to use.</param>
-            <returns>
-            A query whose results evaluate asynchronously and uses the
-            given scheduler for the workhorse task.</returns>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
         </member>
-        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0})">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``5(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{``1,``2,``3,``4})">
             <summary>
-            Returns a query whose results evaluate asynchronously but which
-            are returned in the order of the source.
+            Applies three accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <typeparam name="T">The type of the source elements.</typeparam>
-            <param name="source">The source sequence.</param>
-            <returns>
-            A query whose results evaluate asynchronously but which
-            are returned in the order of the source.</returns>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
             <remarks>
-            Internally, the asynchronous operations will be done concurrently
-            but the results will be yielded in order.
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
             </remarks>
         </member>
-        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered``1(MoreLinq.Experimental.IAwaitQuery{``0})">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``6(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{``1,``2,``3,``4,``5})">
             <summary>
-            Returns a query whose results evaluate asynchronously but which
-            are returned without guarantee of the source order.
+            Applies four accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <typeparam name="T">The type of the source elements.</typeparam>
-            <param name="source">The source sequence.</param>
-            <returns>
-            A query whose results evaluate asynchronously but which
-            are returned without guarantee of the source order.</returns>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
         </member>
-        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Boolean)">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``7(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{``1,``2,``3,``4,``5,``6})">
             <summary>
-            Returns a query whose results evaluate asynchronously and a Boolean
-            argument indicating whether the source order of the results is
-            preserved.
+            Applies five accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <typeparam name="T">The type of the source elements.</typeparam>
-            <param name="source">The source sequence.</param>
-            <param name="value">
-            A Boolean where <c>true</c> means results are in source order and
-            <c>false</c> means that results can be delivered in order of
-            efficiency.</param>
-            <returns>
-            A query whose results evaluate asynchronously and returns the
-            results ordered or unordered based on <paramref name="value"/>.
-            </returns>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
         </member>
-        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Await``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``8(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{System.IObservable{``0},System.IObservable{``6}},System.Func{``1,``2,``3,``4,``5,``6,``7})">
             <summary>
-            Creates a sequence query that streams the result of each task in
-            the source sequence as it completes asynchronously.
+            Applies six accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <typeparam name="T">
-            The type of each task's result as well as the type of the elements
-            of the resulting sequence.</typeparam>
-            <param name="source">The source sequence of tasks.</param>
-            <returns>
-            A sequence query that streams the result of each task in
-            <paramref name="source"/> as it completes asynchronously.
-            </returns>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
+            <typeparam name="TResult6">The type of the result of the sixth accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
             <remarks>
+            <para>This operator executes immediately.</para>
             <para>
-            This method uses deferred execution semantics. The results are
-            yielded as each asynchronous task completes and, by default,
-            not guaranteed to be based on the source sequence order. If order
-            is important, compose further with
-            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>.</para>
-            <para>
-            This method starts a new task where the tasks are awaited. If the
-            resulting sequence is partially consumed then there's a good chance
-            that some tasks will be wasted, those that are in flight.</para>
-            <para>
-            The tasks in <paramref name="source"/> are already assumed to be in
-            flight therefore changing concurrency options via
-            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>, <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32)"/> or
-            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0})"/> will only change how many
-            tasks are awaited at any given moment, not how many will be
-            kept in flight. For the latter effect, use the other overload.
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
             </para>
             </remarks>
         </member>
-        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Await``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.Task{``1}})">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``9(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{System.IObservable{``0},System.IObservable{``6}},System.Func{System.IObservable{``0},System.IObservable{``7}},System.Func{``1,``2,``3,``4,``5,``6,``7,``8})">
             <summary>
-            Creates a sequence query that streams the result of each task in
-            the source sequence as it completes asynchronously. A
-            <see cref="T:System.Threading.CancellationToken"/> is passed for each asynchronous
-            evaluation to abort any asynchronous operations in flight if the
-            sequence is not fully iterated.
+            Applies seven accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <typeparam name="T">The type of the source elements.</typeparam>
-            <typeparam name="TResult">The type of the result elements.</typeparam>
-            <param name="source">The source sequence.</param>
-            <param name="evaluator">A function to begin the asynchronous
-            evaluation of each element, the second parameter of which is a
-            <see cref="T:System.Threading.CancellationToken"/> that can be used to abort
-            asynchronous operations.</param>
-            <returns>
-            A sequence query that stream its results as they are
-            evaluated asynchronously.
-            </returns>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
+            <typeparam name="TResult6">The type of the result of the sixth accumulator.</typeparam>
+            <typeparam name="TResult7">The type of the result of the seventh accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
             <remarks>
+            <para>This operator executes immediately.</para>
             <para>
-            This method uses deferred execution semantics. The results are
-            yielded as each asynchronous evaluation completes and, by default,
-            not guaranteed to be based on the source sequence order. If order
-            is important, compose further with
-            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>.</para>
-            <para>
-            This method starts a new task where the asynchronous evaluations
-            take place and awaited. If the resulting sequence is partially
-            consumed then there's a good chance that some projection work will
-            be wasted and a cooperative effort is done that depends on the
-            <paramref name="evaluator"/> function (via a
-            <see cref="T:System.Threading.CancellationToken"/> as its second argument) to cancel
-            those in flight.</para>
-            <para>
-            The <paramref name="evaluator"/> function should be designed to be
-            thread-agnostic.</para>
-            <para>
-            The task returned by <paramref name="evaluator"/> should be started
-            when the function is called (and not just a mere projection)
-            otherwise changing concurrency options via
-            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>, <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32)"/> or
-            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0})"/> will only change how many
-            tasks are awaited at any given moment, not how many will be
-            kept in flight.
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
             </para>
             </remarks>
         </member>
-        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.Task{``1}},System.Func{``0,System.Threading.Tasks.Task{``1},``2})">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``10(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{System.IObservable{``0},System.IObservable{``6}},System.Func{System.IObservable{``0},System.IObservable{``7}},System.Func{System.IObservable{``0},System.IObservable{``8}},System.Func{``1,``2,``3,``4,``5,``6,``7,``8,``9})">
             <summary>
-            Awaits completion of all asynchronous evaluations irrespective of
-            whether they succeed or fail. An additional argument specifies a
-            function that projects the final result given the source item and
-            completed task.
+            Applies eight accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <typeparam name="T">The type of the source elements.</typeparam>
-            <typeparam name="TTaskResult"> The type of the tasks's result.</typeparam>
-            <typeparam name="TResult">The type of the result elements.</typeparam>
-            <param name="source">The source sequence.</param>
-            <param name="evaluator">A function to begin the asynchronous
-            evaluation of each element, the second parameter of which is a
-            <see cref="T:System.Threading.CancellationToken"/> that can be used to abort
-            asynchronous operations.</param>
-            <param name="resultSelector">A fucntion that projects the final
-            result given the source item and its asynchronous completion
-            result.</param>
-            <returns>
-            A sequence query that stream its results as they are
-            evaluated asynchronously.
-            </returns>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
+            <typeparam name="TResult6">The type of the result of the sixth accumulator.</typeparam>
+            <typeparam name="TResult7">The type of the result of the seventh accumulator.</typeparam>
+            <typeparam name="TResult8">The type of the result of the eighth accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="accumulator8">The eighth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
             <remarks>
+            <para>This operator executes immediately.</para>
             <para>
-            This method uses deferred execution semantics. The results are
-            yielded as each asynchronous evaluation completes and, by default,
-            not guaranteed to be based on the source sequence order. If order
-            is important, compose further with
-            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>.</para>
-            <para>
-            This method starts a new task where the asynchronous evaluations
-            take place and awaited. If the resulting sequence is partially
-            consumed then there's a good chance that some projection work will
-            be wasted and a cooperative effort is done that depends on the
-            <paramref name="evaluator"/> function (via a
-            <see cref="T:System.Threading.CancellationToken"/> as its second argument) to cancel
-            those in flight.</para>
-            <para>
-            The <paramref name="evaluator"/> function should be designed to be
-            thread-agnostic.</para>
-            <para>
-            The task returned by <paramref name="evaluator"/> should be started
-            when the function is called (and not just a mere projection)
-            otherwise changing concurrency options via
-            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>, <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32)"/> or
-            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0})"/> will only change how many
-            tasks are awaited at any given moment, not how many will be
-            kept in flight.
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
             </para>
             </remarks>
         </member>
@@ -5969,6 +6225,226 @@
             This operator executes immediately.
             </remarks>
         </member>
+        <member name="T:MoreLinq.Extensions.AggregateExtension">
+            <summary><c>Aggregate</c> extension.</summary>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``4(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},System.Func{``1,``2,``3})">
+            <summary>
+            Applies two accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``5(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},System.Func{``1,``2,``3,``4})">
+            <summary>
+            Applies three accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``6(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},System.Func{``1,``2,``3,``4,``5})">
+            <summary>
+            Applies four accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``7(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},System.Func{``1,``2,``3,``4,``5,``6})">
+            <summary>
+            Applies five accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``8(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},System.Func{``1,``2,``3,``4,``5,``6,``7})">
+            <summary>
+            Applies six accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``9(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},System.Func{``1,``2,``3,``4,``5,``6,``7,``8})">
+            <summary>
+            Applies seven accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="seed7">The seed value for the seventh accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``10(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},``8,System.Func{``8,``0,``8},System.Func{``1,``2,``3,``4,``5,``6,``7,``8,``9})">
+            <summary>
+            Applies eight accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
+            <typeparam name="TAccumulate8">The type of eighth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="seed7">The seed value for the seventh accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="seed8">The seed value for the eighth accumulator.</param>
+            <param name="accumulator8">The eighth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
         <member name="T:MoreLinq.Extensions.AggregateRightExtension">
             <summary><c>AggregateRight</c> extension.</summary>
         </member>
@@ -6120,7 +6596,12 @@
             <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
             <param name="source">Source sequence.</param>
             <param name="count">Count to assert.</param>
-            <param name="errorSelector">Function that returns the <see cref="T:System.Exception"/> object to throw.</param>
+            <param name="errorSelector">
+            Function that receives a comparison (a negative integer if actual
+            count is less than <paramref name="count"/> and a positive integer
+            if actual count is greater than <paramref name="count"/>) and
+            <paramref name="count"/> as arguments and which returns the
+            <see cref="T:System.Exception"/> object to throw.</param>
             <returns>
             Returns the original sequence as long it is contains the
             number of elements specified by <paramref name="count"/>.
@@ -6749,7 +7230,8 @@
         <member name="M:MoreLinq.Extensions.EquiZipExtension.EquiZip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -6762,6 +7244,9 @@
             A sequence that contains elements of the two input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -6772,17 +7257,14 @@
             "2B", "3C", "4D" in turn.
             </example>
             <remarks>
-            <para>
-            If the two input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.Extensions.EquiZipExtension.EquiZip``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -6797,6 +7279,9 @@
             A sequence that contains elements of the three input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -6808,16 +7293,14 @@
             "2Bb", "3Cc", "4Dd" in turn.
             </example>
             <remarks>
-            <para>If the three input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.Extensions.EquiZipExtension.EquiZip``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="T1">Type of elements in first sequence</typeparam>
             <typeparam name="T2">Type of elements in second sequence</typeparam>
@@ -6834,6 +7317,9 @@
             A sequence that contains elements of the four input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -6846,11 +7332,7 @@
             "2BbFalse", "3CcTrue", "4DdFalse" in turn.
             </example>
             <remarks>
-            <para>
-            If the four input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="T:MoreLinq.Extensions.EvaluateExtension">
@@ -7255,8 +7737,33 @@
             and all nested sequences for which the predicate function
             returned <c>true</c>.
             </returns>
-            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null.</exception>
-            <exception cref="T:System.ArgumentNullException"><paramref name="predicate"/> is null.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="source"/> is <c>null</c>.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="predicate"/> is <c>null</c>.</exception>
+        </member>
+        <member name="M:MoreLinq.Extensions.FlattenExtension.Flatten(System.Collections.IEnumerable,System.Func{System.Object,System.Collections.IEnumerable})">
+            <summary>
+            Flattens a sequence containing arbitrarily-nested sequences. An
+            additional parameter specifies a function that projects an inner
+            sequence via a property of an object.
+            </summary>
+            <param name="source">The sequence that will be flattened.</param>
+            <param name="selector">
+            A function that receives each element of the sequence as an object
+            and projects an inner sequence to be flattened. If the function
+            returns <c>null</c> then the object argument is considered a leaf
+            of the flattening process.
+            </param>
+            <returns>
+            A sequence that contains the elements of <paramref name="source"/>
+            and all nested sequences projected via the
+            <paramref name="selector"/> function.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="source"/> is <c>null</c>.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="selector"/> is <c>null</c>.</exception>
         </member>
         <member name="T:MoreLinq.Extensions.FoldExtension">
             <summary><c>Fold</c> extension.</summary>
@@ -8009,6 +8516,47 @@
             <remarks>This operator uses deferred execution and streams its
             results.</remarks>
         </member>
+        <member name="T:MoreLinq.Extensions.IndexByExtension">
+            <summary><c>IndexBy</c> extension.</summary>
+        </member>
+        <member name="M:MoreLinq.Extensions.IndexByExtension.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
+            <summary>
+            Applies a key-generating function to each element of a sequence and
+            returns a sequence that contains the elements of the original
+            sequence as well its key and index inside the group of its key.
+            </summary>
+            <typeparam name="TSource">Type of the source sequence elements.</typeparam>
+            <typeparam name="TKey">Type of the projected key.</typeparam>
+            <param name="source">Source sequence.</param>
+            <param name="keySelector">
+            Function that projects the key given an element in the source sequence.</param>
+            <returns>
+            A sequence of elements paired with their index within the key-group.
+            The index is the key and the element is the value of the pair.
+            </returns>
+        </member>
+        <member name="M:MoreLinq.Extensions.IndexByExtension.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
+            <summary>
+            Applies a key-generating function to each element of a sequence and
+            returns a sequence that contains the elements of the original
+            sequence as well its key and index inside the group of its key.
+            An additional parameter specifies a comparer to use for testing the
+            equivalence of keys.
+            </summary>
+            <typeparam name="TSource">Type of the source sequence elements.</typeparam>
+            <typeparam name="TKey">Type of the projected key.</typeparam>
+            <param name="source">Source sequence.</param>
+            <param name="keySelector">
+            Function that projects the key given an element in the source sequence.</param>
+            <param name="comparer">
+            The equality comparer to use to determine whether or not keys are
+            equal. If <c>null</c>, the default equality comparer for
+            <typeparamref name="TSource"/> is used.</param>
+            <returns>
+            A sequence of elements paired with their index within the key-group.
+            The index is the key and the element is the value of the pair.
+            </returns>
+        </member>
         <member name="T:MoreLinq.Extensions.InsertExtension">
             <summary><c>Insert</c> extension.</summary>
         </member>
@@ -8762,7 +9310,9 @@
             <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
             <param name="source">The sequence to pad.</param>
             <param name="width">The width/length below which to pad.</param>
-            <param name="paddingSelector">Function to calculate padding.</param>
+            <param name="paddingSelector">
+            Function to calculate padding given the index of the missing element.
+            </param>
             <returns>
             Returns a sequence that is at least as wide/long as the width/length
             specified by the <paramref name="width"/> parameter.
@@ -8801,11 +9351,11 @@
             </remarks>
             <example>
             <code><![CDATA[
-            int[] numbers = { 123, 456, 789 };
-            var result = numbers.Pairwise((a, b) => a + b);
+            var source = new[] { "a", "b", "c", "d" };
+            var result = source.Pairwise((a, b) => a + b);
             ]]></code>
             The <c>result</c> variable, when iterated over, will yield
-            579 and 1245, in turn.
+            "ab", "bc" and "cd", in turn.
             </example>
         </member>
         <member name="T:MoreLinq.Extensions.PartialSortExtension">
@@ -9529,7 +10079,7 @@
         </member>
         <member name="M:MoreLinq.Extensions.ScanExtension.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
             <summary>
-            Peforms a scan (inclusive prefix sum) on a sequence of elements.
+            Performs a scan (inclusive prefix sum) on a sequence of elements.
             </summary>
             <remarks>
             An inclusive prefix sum returns an equal-length sequence where the
@@ -9577,6 +10127,53 @@
             <param name="transformation">Transformation operation</param>
             <returns>The scanned sequence</returns>
         </member>
+        <member name="T:MoreLinq.Extensions.ScanByExtension">
+            <summary><c>ScanBy</c> extension.</summary>
+        </member>
+        <member name="M:MoreLinq.Extensions.ScanByExtension.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2})">
+            <summary>
+            Applies an accumulator function over sequence element keys,
+            returning the keys along with intermediate accumulator states.
+            </summary>
+            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
+            <typeparam name="TKey">The type of the key.</typeparam>
+            <typeparam name="TState">Type of the state.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="keySelector">
+            A function that returns the key given an element.</param>
+            <param name="seedSelector">
+            A function to determine the initial value for the accumulator that is
+            invoked once per key encountered.</param>
+            <param name="accumulator">
+            An accumulator function invoked for each element.</param>
+            <returns>
+            A sequence of keys paired with intermediate accumulator states.
+            </returns>
+        </member>
+        <member name="M:MoreLinq.Extensions.ScanByExtension.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
+            <summary>
+            Applies an accumulator function over sequence element keys,
+            returning the keys along with intermediate accumulator states. An
+            additional parameter specifies the comparer to use to compare keys.
+            </summary>
+            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
+            <typeparam name="TKey">The type of the key.</typeparam>
+            <typeparam name="TState">Type of the state.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="keySelector">
+            A function that returns the key given an element.</param>
+            <param name="seedSelector">
+            A function to determine the initial value for the accumulator that is
+            invoked once per key encountered.</param>
+            <param name="accumulator">
+            An accumulator function invoked for each element.</param>
+            <param name="comparer">The equality comparer to use to determine
+            whether or not keys are equal. If <c>null</c>, the default equality
+            comparer for <typeparamref name="TSource"/> is used.</param>
+            <returns>
+            A sequence of keys paired with intermediate accumulator states.
+            </returns>
+        </member>
         <member name="T:MoreLinq.Extensions.ScanRightExtension">
             <summary><c>ScanRight</c> extension.</summary>
         </member>
@@ -11062,7 +11659,10 @@
         <member name="M:MoreLinq.Extensions.ZipLongestExtension.ZipLongest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -11085,19 +11685,16 @@
             "2B", "3C", "0D" in turn.
             </example>
             <remarks>
-            <para>
-            If the two input sequences are of different lengths then the result
-            sequence will always be as long as the longer of the two input
-            sequences. The default value of the shorter sequence element type
-            is used for padding.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.Extensions.ZipLongestExtension.ZipLongest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -11123,20 +11720,16 @@
             "2Bb", "3Cc", "0Dd", "0e" in turn.
             </example>
             <remarks>
-            <para>
-            If the input sequences are of different lengths then the result
-            sequence will always be as long as the longest of input sequences.
-            The default value of the each shorter sequence element type is used
-            for padding. This operator uses deferred execution and streams its
-            results.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.Extensions.ZipLongestExtension.ZipLongest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="T1">Type of elements in first sequence</typeparam>
             <typeparam name="T2">Type of elements in second sequence</typeparam>
@@ -11165,13 +11758,7 @@
             "2BbFalse", "3CcTrue", "0DdFalse", "0eTrue", "0\0False" in turn.
             </example>
             <remarks>
-            <para>
-            If the input sequences are of different lengths then the result
-            sequence will always be as long as the longest of input sequences.
-            The default value of the each shorter sequence element type is used
-            for padding.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="T:MoreLinq.Extensions.ZipShortestExtension">
@@ -11179,8 +11766,9 @@
         </member>
         <member name="M:MoreLinq.Extensions.ZipShortestExtension.ZipShortest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -11202,9 +11790,10 @@
             </example>
             <remarks>
             <para>
-            If the two input sequences are of different lengths, the result
-            sequence is terminated as soon as the shortest input sequence is
-            exhausted.</para>
+            If the input sequences are of different lengths, the result sequence
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
+            </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
             </remarks>
@@ -11212,7 +11801,8 @@
         <member name="M:MoreLinq.Extensions.ZipShortestExtension.ZipShortest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element  from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -11239,7 +11829,8 @@
             <remarks>
             <para>
             If the input sequences are of different lengths, the result sequence
-            is terminated as soon as the shortest input sequence is exhausted.
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
             </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
@@ -11248,7 +11839,8 @@
         <member name="M:MoreLinq.Extensions.ZipShortestExtension.ZipShortest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -11278,69 +11870,13 @@
             <remarks>
             <para>
             If the input sequences are of different lengths, the result sequence
-            is terminated as soon as the shortest input sequence is exhausted.
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
             </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
             </remarks>
         </member>
-        <member name="T:MoreLinq.Extensions.ToDataTableExtension">
-            <summary><c>ToDataTable</c> extension.</summary>
-        </member>
-        <member name="M:MoreLinq.Extensions.ToDataTableExtension.ToDataTable``1(System.Collections.Generic.IEnumerable{``0})">
-            <summary>
-            Converts a sequence to a <see cref="T:System.Data.DataTable"/> object.
-            </summary>
-            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
-            <param name="source">The source.</param>
-            <returns>
-            A <see cref="T:System.Data.DataTable"/> representing the source.
-            </returns>
-            <remarks>This operator uses immediate execution.</remarks>
-        </member>
-        <member name="M:MoreLinq.Extensions.ToDataTableExtension.ToDataTable``1(System.Collections.Generic.IEnumerable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
-            <summary>
-            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/>
-            object with a set of lambda expressions specifying which members (property
-            or field) of each element in the sequence will supply the column values.
-            </summary>
-            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
-            <param name="source">The source.</param>
-            <param name="expressions">Expressions providing access to element members.</param>
-            <returns>
-            A <see cref="T:System.Data.DataTable"/> representing the source.
-            </returns>
-            <remarks>This operator uses immediate execution.</remarks>
-        </member>
-        <member name="M:MoreLinq.Extensions.ToDataTableExtension.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1)">
-            <summary>
-            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/> object.
-            </summary>
-            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
-            <typeparam name="TTable"></typeparam>
-            <param name="source">The source.</param>
-            <param name="table"></param>
-            <returns>
-            A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
-            </returns>
-            <remarks>This operator uses immediate execution.</remarks>
-        </member>
-        <member name="M:MoreLinq.Extensions.ToDataTableExtension.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1,System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
-            <summary>
-            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/>
-            object with a set of lambda expressions specifying which members (property
-            or field) of each element in the sequence will supply the column values.
-            </summary>
-            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
-            <typeparam name="TTable">The type of the input and resulting <see cref="T:System.Data.DataTable"/> object.</typeparam>
-            <param name="source">The source.</param>
-            <param name="table">The <see cref="T:System.Data.DataTable"/> type of object where to add rows</param>
-            <param name="expressions">Expressions providing access to element members.</param>
-            <returns>
-            A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
-            </returns>
-            <remarks>This operator uses immediate execution.</remarks>
-        </member>
         <member name="T:MoreLinq.IListLike`1">
             <summary>
             Represents an list-like (indexable) data structure.
@@ -11409,6 +11945,28 @@
             of an item to prepend, an item to append and the source.
             </summary>
         </member>
+        <member name="T:MoreLinq.Reactive.Observable">
+            <summary>
+            Provides a set of static methods for writing in-memory queries over observable sequences.
+            </summary>
+        </member>
+        <member name="M:MoreLinq.Reactive.Observable.Subscribe``1(System.IObservable{``0},System.Action{``0},System.Action{System.Exception},System.Action)">
+            <summary>
+            Subscribes an element handler and a completion handler to an
+            observable sequence.
+            </summary>
+            <typeparam name="T">Type of elements in <paramref name="source"/>.</typeparam>
+            <param name="source">Observable sequence to subscribe to.</param>
+            <param name="onNext">
+            Action to invoke for each element in <paramref name="source"/>.</param>
+            <param name="onError">
+            Action to invoke upon exceptional termination of the
+            <paramref name="source"/>.</param>
+            <param name="onCompleted">
+            Action to invoke upon graceful termination of <paramref name="source"/>.</param>
+            <returns>The subscription, which when disposed, will unsubscribe
+            from <paramref name="source"/>.</returns>
+        </member>
         <member name="T:MoreLinq.SequenceException">
             <summary>
             The exception that is thrown for a sequence that fails a condition.
@@ -11435,13 +11993,5 @@
             <param name="message">A message that describes the error.</param>
             <param name="innerException">The exception that is the cause of the current exception.</param>
         </member>
-        <member name="M:MoreLinq.SequenceException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
-            <summary>
-            Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class
-            with serialized data.
-            </summary>
-            <param name="info">The object that holds the serialized object data.</param>
-            <param name="context">The contextual information about the source or destination.</param>
-        </member>
     </members>
 </doc>
diff --git a/morelinq.3.2.0/lib/netstandard2.0/MoreLinq.dll b/morelinq.3.2.0/lib/netstandard2.0/MoreLinq.dll
new file mode 100644
index 0000000..c8f5169
Binary files /dev/null and b/morelinq.3.2.0/lib/netstandard2.0/MoreLinq.dll differ
diff --git a/morelinq.3.2.0/lib/netstandard2.0/MoreLinq.pdb b/morelinq.3.2.0/lib/netstandard2.0/MoreLinq.pdb
new file mode 100644
index 0000000..4864f4b
Binary files /dev/null and b/morelinq.3.2.0/lib/netstandard2.0/MoreLinq.pdb differ
diff --git a/morelinq.3.0.0/lib/netstandard1.0/MoreLinq.xml b/morelinq.3.2.0/lib/netstandard2.0/MoreLinq.xml
similarity index 87%
rename from morelinq.3.0.0/lib/netstandard1.0/MoreLinq.xml
rename to morelinq.3.2.0/lib/netstandard2.0/MoreLinq.xml
index 05ca752..79de6ed 100644
--- a/morelinq.3.0.0/lib/netstandard1.0/MoreLinq.xml
+++ b/morelinq.3.2.0/lib/netstandard2.0/MoreLinq.xml
@@ -27,6 +27,223 @@
             This operator executes immediately.
             </remarks>
         </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``4(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},System.Func{``1,``2,``3})">
+            <summary>
+            Applies two accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``5(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},System.Func{``1,``2,``3,``4})">
+            <summary>
+            Applies three accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``6(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},System.Func{``1,``2,``3,``4,``5})">
+            <summary>
+            Applies four accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``7(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},System.Func{``1,``2,``3,``4,``5,``6})">
+            <summary>
+            Applies five accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``8(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},System.Func{``1,``2,``3,``4,``5,``6,``7})">
+            <summary>
+            Applies six accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``9(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},System.Func{``1,``2,``3,``4,``5,``6,``7,``8})">
+            <summary>
+            Applies seven accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="seed7">The seed value for the seventh accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Aggregate``10(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},``8,System.Func{``8,``0,``8},System.Func{``1,``2,``3,``4,``5,``6,``7,``8,``9})">
+            <summary>
+            Applies eight accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
+            <typeparam name="TAccumulate8">The type of eighth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="seed7">The seed value for the seventh accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="seed8">The seed value for the eighth accumulator.</param>
+            <param name="accumulator8">The eighth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
         <member name="M:MoreLinq.MoreEnumerable.AggregateRight``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
             <summary>
             Applies a right-associative accumulator function over a sequence.
@@ -176,7 +393,12 @@
             <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
             <param name="source">Source sequence.</param>
             <param name="count">Count to assert.</param>
-            <param name="errorSelector">Function that returns the <see cref="T:System.Exception"/> object to throw.</param>
+            <param name="errorSelector">
+            Function that receives a comparison (a negative integer if actual
+            count is less than <paramref name="count"/> and a positive integer
+            if actual count is greater than <paramref name="count"/>) and
+            <paramref name="count"/> as arguments and which returns the
+            <see cref="T:System.Exception"/> object to throw.</param>
             <returns>
             Returns the original sequence as long it is contains the
             number of elements specified by <paramref name="count"/>.
@@ -783,7 +1005,8 @@
         <member name="M:MoreLinq.MoreEnumerable.EquiZip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -796,6 +1019,9 @@
             A sequence that contains elements of the two input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -806,17 +1032,14 @@
             "2B", "3C", "4D" in turn.
             </example>
             <remarks>
-            <para>
-            If the two input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.EquiZip``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -831,6 +1054,9 @@
             A sequence that contains elements of the three input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -842,16 +1068,14 @@
             "2Bb", "3Cc", "4Dd" in turn.
             </example>
             <remarks>
-            <para>If the three input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.EquiZip``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="T1">Type of elements in first sequence</typeparam>
             <typeparam name="T2">Type of elements in second sequence</typeparam>
@@ -868,6 +1092,9 @@
             A sequence that contains elements of the four input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -880,11 +1107,7 @@
             "2BbFalse", "3CcTrue", "4DdFalse" in turn.
             </example>
             <remarks>
-            <para>
-            If the four input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.Evaluate``1(System.Collections.Generic.IEnumerable{System.Func{``0}})">
@@ -1213,8 +1436,33 @@
             and all nested sequences for which the predicate function
             returned <c>true</c>.
             </returns>
-            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null.</exception>
-            <exception cref="T:System.ArgumentNullException"><paramref name="predicate"/> is null.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="source"/> is <c>null</c>.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="predicate"/> is <c>null</c>.</exception>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.Flatten(System.Collections.IEnumerable,System.Func{System.Object,System.Collections.IEnumerable})">
+            <summary>
+            Flattens a sequence containing arbitrarily-nested sequences. An
+            additional parameter specifies a function that projects an inner
+            sequence via a property of an object.
+            </summary>
+            <param name="source">The sequence that will be flattened.</param>
+            <param name="selector">
+            A function that receives each element of the sequence as an object
+            and projects an inner sequence to be flattened. If the function
+            returns <c>null</c> then the object argument is considered a leaf
+            of the flattening process.
+            </param>
+            <returns>
+            A sequence that contains the elements of <paramref name="source"/>
+            and all nested sequences projected via the
+            <paramref name="selector"/> function.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="source"/> is <c>null</c>.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="selector"/> is <c>null</c>.</exception>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
             <summary>
@@ -2043,6 +2291,44 @@
             <remarks>This operator uses deferred execution and streams its
             results.</remarks>
         </member>
+        <member name="M:MoreLinq.MoreEnumerable.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
+            <summary>
+            Applies a key-generating function to each element of a sequence and
+            returns a sequence that contains the elements of the original
+            sequence as well its key and index inside the group of its key.
+            </summary>
+            <typeparam name="TSource">Type of the source sequence elements.</typeparam>
+            <typeparam name="TKey">Type of the projected key.</typeparam>
+            <param name="source">Source sequence.</param>
+            <param name="keySelector">
+            Function that projects the key given an element in the source sequence.</param>
+            <returns>
+            A sequence of elements paired with their index within the key-group.
+            The index is the key and the element is the value of the pair.
+            </returns>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
+            <summary>
+            Applies a key-generating function to each element of a sequence and
+            returns a sequence that contains the elements of the original
+            sequence as well its key and index inside the group of its key.
+            An additional parameter specifies a comparer to use for testing the
+            equivalence of keys.
+            </summary>
+            <typeparam name="TSource">Type of the source sequence elements.</typeparam>
+            <typeparam name="TKey">Type of the projected key.</typeparam>
+            <param name="source">Source sequence.</param>
+            <param name="keySelector">
+            Function that projects the key given an element in the source sequence.</param>
+            <param name="comparer">
+            The equality comparer to use to determine whether or not keys are
+            equal. If <c>null</c>, the default equality comparer for
+            <typeparamref name="TSource"/> is used.</param>
+            <returns>
+            A sequence of elements paired with their index within the key-group.
+            The index is the key and the element is the value of the pair.
+            </returns>
+        </member>
         <member name="M:MoreLinq.MoreEnumerable.Insert``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Int32)">
             <summary>
             Inserts the elements of a sequence into another sequence at a
@@ -2883,7 +3169,9 @@
             <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
             <param name="source">The sequence to pad.</param>
             <param name="width">The width/length below which to pad.</param>
-            <param name="paddingSelector">Function to calculate padding.</param>
+            <param name="paddingSelector">
+            Function to calculate padding given the index of the missing element.
+            </param>
             <returns>
             Returns a sequence that is at least as wide/long as the width/length
             specified by the <paramref name="width"/> parameter.
@@ -2919,11 +3207,11 @@
             </remarks>
             <example>
             <code><![CDATA[
-            int[] numbers = { 123, 456, 789 };
-            var result = numbers.Pairwise((a, b) => a + b);
+            var source = new[] { "a", "b", "c", "d" };
+            var result = source.Pairwise((a, b) => a + b);
             ]]></code>
             The <c>result</c> variable, when iterated over, will yield
-            579 and 1245, in turn.
+            "ab", "bc" and "cd", in turn.
             </example>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
@@ -3780,7 +4068,7 @@
         </member>
         <member name="M:MoreLinq.MoreEnumerable.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
             <summary>
-            Peforms a scan (inclusive prefix sum) on a sequence of elements.
+            Performs a scan (inclusive prefix sum) on a sequence of elements.
             </summary>
             <remarks>
             An inclusive prefix sum returns an equal-length sequence where the
@@ -3828,6 +4116,50 @@
             <param name="transformation">Transformation operation</param>
             <returns>The scanned sequence</returns>
         </member>
+        <member name="M:MoreLinq.MoreEnumerable.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2})">
+            <summary>
+            Applies an accumulator function over sequence element keys,
+            returning the keys along with intermediate accumulator states.
+            </summary>
+            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
+            <typeparam name="TKey">The type of the key.</typeparam>
+            <typeparam name="TState">Type of the state.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="keySelector">
+            A function that returns the key given an element.</param>
+            <param name="seedSelector">
+            A function to determine the initial value for the accumulator that is
+            invoked once per key encountered.</param>
+            <param name="accumulator">
+            An accumulator function invoked for each element.</param>
+            <returns>
+            A sequence of keys paired with intermediate accumulator states.
+            </returns>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
+            <summary>
+            Applies an accumulator function over sequence element keys,
+            returning the keys along with intermediate accumulator states. An
+            additional parameter specifies the comparer to use to compare keys.
+            </summary>
+            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
+            <typeparam name="TKey">The type of the key.</typeparam>
+            <typeparam name="TState">Type of the state.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="keySelector">
+            A function that returns the key given an element.</param>
+            <param name="seedSelector">
+            A function to determine the initial value for the accumulator that is
+            invoked once per key encountered.</param>
+            <param name="accumulator">
+            An accumulator function invoked for each element.</param>
+            <param name="comparer">The equality comparer to use to determine
+            whether or not keys are equal. If <c>null</c>, the default equality
+            comparer for <typeparamref name="TSource"/> is used.</param>
+            <returns>
+            A sequence of keys paired with intermediate accumulator states.
+            </returns>
+        </member>
         <member name="M:MoreLinq.MoreEnumerable.ScanRight``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
             <summary>
             Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
@@ -4634,6 +4966,66 @@
             resulting array.
             </remarks>
         </member>
+        <member name="M:MoreLinq.MoreEnumerable.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1)">
+            <summary>
+            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/> object.
+            </summary>
+            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
+            <typeparam name="TTable"></typeparam>
+            <param name="source">The source.</param>
+            <param name="table"></param>
+            <returns>
+            A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
+            </returns>
+            <remarks>This operator uses immediate execution.</remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.ToDataTable``1(System.Collections.Generic.IEnumerable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
+            <summary>
+            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/>
+            object with a set of lambda expressions specifying which members (property
+            or field) of each element in the sequence will supply the column values.
+            </summary>
+            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
+            <param name="source">The source.</param>
+            <param name="expressions">Expressions providing access to element members.</param>
+            <returns>
+            A <see cref="T:System.Data.DataTable"/> representing the source.
+            </returns>
+            <remarks>This operator uses immediate execution.</remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.ToDataTable``1(System.Collections.Generic.IEnumerable{``0})">
+            <summary>
+            Converts a sequence to a <see cref="T:System.Data.DataTable"/> object.
+            </summary>
+            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
+            <param name="source">The source.</param>
+            <returns>
+            A <see cref="T:System.Data.DataTable"/> representing the source.
+            </returns>
+            <remarks>This operator uses immediate execution.</remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1,System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
+            <summary>
+            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/>
+            object with a set of lambda expressions specifying which members (property
+            or field) of each element in the sequence will supply the column values.
+            </summary>
+            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
+            <typeparam name="TTable">The type of the input and resulting <see cref="T:System.Data.DataTable"/> object.</typeparam>
+            <param name="source">The source.</param>
+            <param name="table">The <see cref="T:System.Data.DataTable"/> type of object where to add rows</param>
+            <param name="expressions">Expressions providing access to element members.</param>
+            <returns>
+            A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
+            </returns>
+            <remarks>This operator uses immediate execution.</remarks>
+        </member>
+        <member name="M:MoreLinq.MoreEnumerable.BuildOrBindSchema(System.Data.DataTable,System.Reflection.MemberInfo[])">
+            <remarks>
+            The resulting array may contain null entries and those represent
+            columns for which there is no source member supplying a value.
+            </remarks>
+        </member>
         <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString``1(System.Collections.Generic.IEnumerable{``0},System.String)">
             <summary>
             Creates a delimited string from a sequence of values and
@@ -5334,7 +5726,10 @@
         <member name="M:MoreLinq.MoreEnumerable.ZipLongest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -5357,19 +5752,16 @@
             "2B", "3C", "0D" in turn.
             </example>
             <remarks>
-            <para>
-            If the two input sequences are of different lengths then the result
-            sequence will always be as long as the longer of the two input
-            sequences. The default value of the shorter sequence element type
-            is used for padding.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.ZipLongest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -5395,20 +5787,16 @@
             "2Bb", "3Cc", "0Dd", "0e" in turn.
             </example>
             <remarks>
-            <para>
-            If the input sequences are of different lengths then the result
-            sequence will always be as long as the longest of input sequences.
-            The default value of the each shorter sequence element type is used
-            for padding. This operator uses deferred execution and streams its
-            results.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.ZipLongest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="T1">Type of elements in first sequence</typeparam>
             <typeparam name="T2">Type of elements in second sequence</typeparam>
@@ -5437,19 +5825,14 @@
             "2BbFalse", "3CcTrue", "0DdFalse", "0eTrue", "0\0False" in turn.
             </example>
             <remarks>
-            <para>
-            If the input sequences are of different lengths then the result
-            sequence will always be as long as the longest of input sequences.
-            The default value of the each shorter sequence element type is used
-            for padding.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.MoreEnumerable.ZipShortest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -5471,9 +5854,10 @@
             </example>
             <remarks>
             <para>
-            If the two input sequences are of different lengths, the result
-            sequence is terminated as soon as the shortest input sequence is
-            exhausted.</para>
+            If the input sequences are of different lengths, the result sequence
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
+            </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
             </remarks>
@@ -5481,7 +5865,8 @@
         <member name="M:MoreLinq.MoreEnumerable.ZipShortest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element  from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -5508,7 +5893,8 @@
             <remarks>
             <para>
             If the input sequences are of different lengths, the result sequence
-            is terminated as soon as the shortest input sequence is exhausted.
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
             </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
@@ -5517,7 +5903,8 @@
         <member name="M:MoreLinq.MoreEnumerable.ZipShortest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -5547,7 +5934,8 @@
             <remarks>
             <para>
             If the input sequences are of different lengths, the result sequence
-            is terminated as soon as the shortest input sequence is exhausted.
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
             </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
@@ -5566,79 +5954,885 @@
             UTILITY AND DESIGN/IMPLEMENTATION DEFECTS.</strong></para>
             </summary>
         </member>
-        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Memoize``1(System.Collections.Generic.IEnumerable{``0})">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``4(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{``1,``2,``3})">
             <summary>
-            Creates a sequence that lazily caches the source as it is iterated
-            for the first time, reusing the cache thereafter for future
-            re-iterations. If the source is already cached or buffered then it
-            is returned verbatim.
+            Applies two accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <typeparam name="T">
-            Type of elements in <paramref name="source"/>.</typeparam>
-            <param name="source">The source sequence.</param>
-            <returns>
-            Returns a sequence that corresponds to a cached version of the
-            input sequence.</returns>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
             <remarks>
-            The returned <see cref="T:System.Collections.Generic.IEnumerable`1"/> will cache items from
-            <paramref name="source"/> in a thread-safe manner. Each thread can
-            call its <see cref="M:System.Collections.Generic.IEnumerable`1.GetEnumerator"/> to acquire an
-            iterator  but the same iterator should not be used simultanesouly
-            from multiple threads. The sequence supplied in
-            <paramref name="source"/> is not expected to be thread-safe but it
-            is required to be thread-agnostic because different threads
-            (though never simultaneously) may iterate over the sequence.
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
             </remarks>
         </member>
-        <member name="T:MoreLinq.Extensions.AcquireExtension">
-            <summary><c>Acquire</c> extension.</summary>
-        </member>
-        <member name="M:MoreLinq.Extensions.AcquireExtension.Acquire``1(System.Collections.Generic.IEnumerable{``0})">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``5(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{``1,``2,``3,``4})">
             <summary>
-            Ensures that a source sequence of <see cref="T:System.IDisposable"/>
-            objects are all acquired successfully. If the acquisition of any
-            one <see cref="T:System.IDisposable"/> fails then those successfully
-            acquired till that point are disposed.
+            Applies three accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
-            <param name="source">Source sequence of <see cref="T:System.IDisposable"/> objects.</param>
-            <returns>
-            Returns an array of all the acquired <see cref="T:System.IDisposable"/>
-            objects in source order.
-            </returns>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
             <remarks>
-            This operator executes immediately.
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
             </remarks>
         </member>
-        <member name="T:MoreLinq.Extensions.AggregateRightExtension">
-            <summary><c>AggregateRight</c> extension.</summary>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``6(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{``1,``2,``3,``4,``5})">
+            <summary>
+            Applies four accumulator queries sequentially in a single
+            pass over a sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
         </member>
-        <member name="M:MoreLinq.Extensions.AggregateRightExtension.AggregateRight``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``7(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{``1,``2,``3,``4,``5,``6})">
             <summary>
-            Applies a right-associative accumulator function over a sequence.
-            This operator is the right-associative version of the
-            <see cref="M:System.Linq.Enumerable.Aggregate``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})"/> LINQ operator.
+            Applies five accumulator queries sequentially in a single
+            pass over a sequence.
             </summary>
-            <typeparam name="TSource">The type of the elements of source.</typeparam>
-            <param name="source">Source sequence.</param>
-            <param name="func">A right-associative accumulator function to be invoked on each element.</param>
-            <returns>The final accumulator value.</returns>
-            <example>
-            <code><![CDATA[
-            string result = Enumerable.Range(1, 5).Select(i => i.ToString()).AggregateRight((a, b) => string.Format("({0}/{1})", a, b));
-            ]]></code>
-            The <c>result</c> variable will contain <c>"(1/(2/(3/(4/5))))"</c>.
-            </example>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
             <remarks>
-            This operator executes immediately.
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
             </remarks>
         </member>
-        <member name="M:MoreLinq.Extensions.AggregateRightExtension.AggregateRight``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``0,``1,``1})">
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``8(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{System.IObservable{``0},System.IObservable{``6}},System.Func{``1,``2,``3,``4,``5,``6,``7})">
             <summary>
-            Applies a right-associative accumulator function over a sequence.
-            The specified seed value is used as the initial accumulator value.
-            This operator is the right-associative version of the
-            <see cref="M:System.Linq.Enumerable.Aggregate``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1})"/> LINQ operator.
+            Applies six accumulator queries sequentially in a single
+            pass over a sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
+            <typeparam name="TResult6">The type of the result of the sixth accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``9(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{System.IObservable{``0},System.IObservable{``6}},System.Func{System.IObservable{``0},System.IObservable{``7}},System.Func{``1,``2,``3,``4,``5,``6,``7,``8})">
+            <summary>
+            Applies seven accumulator queries sequentially in a single
+            pass over a sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
+            <typeparam name="TResult6">The type of the result of the sixth accumulator.</typeparam>
+            <typeparam name="TResult7">The type of the result of the seventh accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Aggregate``10(System.Collections.Generic.IEnumerable{``0},System.Func{System.IObservable{``0},System.IObservable{``1}},System.Func{System.IObservable{``0},System.IObservable{``2}},System.Func{System.IObservable{``0},System.IObservable{``3}},System.Func{System.IObservable{``0},System.IObservable{``4}},System.Func{System.IObservable{``0},System.IObservable{``5}},System.Func{System.IObservable{``0},System.IObservable{``6}},System.Func{System.IObservable{``0},System.IObservable{``7}},System.Func{System.IObservable{``0},System.IObservable{``8}},System.Func{``1,``2,``3,``4,``5,``6,``7,``8,``9})">
+            <summary>
+            Applies eight accumulator queries sequentially in a single
+            pass over a sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TResult1">The type of the result of the first accumulator.</typeparam>
+            <typeparam name="TResult2">The type of the result of the second accumulator.</typeparam>
+            <typeparam name="TResult3">The type of the result of the third accumulator.</typeparam>
+            <typeparam name="TResult4">The type of the result of the fourth accumulator.</typeparam>
+            <typeparam name="TResult5">The type of the result of the fifth accumulator.</typeparam>
+            <typeparam name="TResult6">The type of the result of the sixth accumulator.</typeparam>
+            <typeparam name="TResult7">The type of the result of the seventh accumulator.</typeparam>
+            <typeparam name="TResult8">The type of the result of the eighth accumulator.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="accumulator8">The eighth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <exception cref="T:System.InvalidOperationException">
+            An <see cref="T:System.IObservable`1"/> returned by an accumulator function
+            produced zero or more than a single aggregate result.
+            </exception>
+            <remarks>
+            <para>This operator executes immediately.</para>
+            <para>
+            Each accumulator argument is a function that receives an
+            <see cref="T:System.IObservable`1"/>, which when subscribed to, produces the
+            items in the <paramref name="source"/> sequence and in original
+            order; the function must then return an <see cref="T:System.IObservable`1"/>
+            that produces a single aggregate on completion (when
+            <see cref="M:System.IObserver`1.OnCompleted"/> is called. An error is raised
+            at run-time if the <see cref="T:System.IObserver`1"/> returned by an
+            accumulator function produces no result or produces more than a
+            single result.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0})">
+            <summary>
+            Converts a query whose results evaluate asynchronously to use
+            sequential instead of concurrent evaluation.
+            </summary>
+            <typeparam name="T">The type of the source elements.</typeparam>
+            <param name="source">The source sequence.</param>
+            <returns>The converted sequence.</returns>
+        </member>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32)">
+            <summary>
+            Returns a query whose results evaluate asynchronously to use a
+            concurrency limit.
+            </summary>
+            <typeparam name="T">The type of the source elements.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="value"></param>
+            <returns>
+            A query whose results evaluate asynchronously using the given
+            concurrency limit.</returns>
+        </member>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0})">
+            <summary>
+            Returns a query whose results evaluate asynchronously and
+            concurrently with no defined limitation on concurrency.
+            </summary>
+            <typeparam name="T">The type of the source elements.</typeparam>
+            <param name="source">The source sequence.</param>
+            <returns>
+            A query whose results evaluate asynchronously using no defined
+            limitation on concurrency.</returns>
+        </member>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Scheduler``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Threading.Tasks.TaskScheduler)">
+            <summary>
+            Returns a query whose results evaluate asynchronously and uses the
+            given scheduler for the workhorse task.
+            </summary>
+            <typeparam name="T">The type of the source elements.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="value">The scheduler to use.</param>
+            <returns>
+            A query whose results evaluate asynchronously and uses the
+            given scheduler for the workhorse task.</returns>
+        </member>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0})">
+            <summary>
+            Returns a query whose results evaluate asynchronously but which
+            are returned in the order of the source.
+            </summary>
+            <typeparam name="T">The type of the source elements.</typeparam>
+            <param name="source">The source sequence.</param>
+            <returns>
+            A query whose results evaluate asynchronously but which
+            are returned in the order of the source.</returns>
+            <remarks>
+            Internally, the asynchronous operations will be done concurrently
+            but the results will be yielded in order.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered``1(MoreLinq.Experimental.IAwaitQuery{``0})">
+            <summary>
+            Returns a query whose results evaluate asynchronously but which
+            are returned without guarantee of the source order.
+            </summary>
+            <typeparam name="T">The type of the source elements.</typeparam>
+            <param name="source">The source sequence.</param>
+            <returns>
+            A query whose results evaluate asynchronously but which
+            are returned without guarantee of the source order.</returns>
+        </member>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Boolean)">
+            <summary>
+            Returns a query whose results evaluate asynchronously and a Boolean
+            argument indicating whether the source order of the results is
+            preserved.
+            </summary>
+            <typeparam name="T">The type of the source elements.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="value">
+            A Boolean where <c>true</c> means results are in source order and
+            <c>false</c> means that results can be delivered in order of
+            efficiency.</param>
+            <returns>
+            A query whose results evaluate asynchronously and returns the
+            results ordered or unordered based on <paramref name="value"/>.
+            </returns>
+        </member>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Await``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}})">
+            <summary>
+            Creates a sequence query that streams the result of each task in
+            the source sequence as it completes asynchronously.
+            </summary>
+            <typeparam name="T">
+            The type of each task's result as well as the type of the elements
+            of the resulting sequence.</typeparam>
+            <param name="source">The source sequence of tasks.</param>
+            <returns>
+            A sequence query that streams the result of each task in
+            <paramref name="source"/> as it completes asynchronously.
+            </returns>
+            <remarks>
+            <para>
+            This method uses deferred execution semantics. The results are
+            yielded as each asynchronous task completes and, by default,
+            not guaranteed to be based on the source sequence order. If order
+            is important, compose further with
+            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>.</para>
+            <para>
+            This method starts a new task where the tasks are awaited. If the
+            resulting sequence is partially consumed then there's a good chance
+            that some tasks will be wasted, those that are in flight.</para>
+            <para>
+            The tasks in <paramref name="source"/> are already assumed to be in
+            flight therefore changing concurrency options via
+            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>, <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32)"/> or
+            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0})"/> will only change how many
+            tasks are awaited at any given moment, not how many will be
+            kept in flight. For the latter effect, use the other overload.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Await``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.Task{``1}})">
+            <summary>
+            Creates a sequence query that streams the result of each task in
+            the source sequence as it completes asynchronously. A
+            <see cref="T:System.Threading.CancellationToken"/> is passed for each asynchronous
+            evaluation to abort any asynchronous operations in flight if the
+            sequence is not fully iterated.
+            </summary>
+            <typeparam name="T">The type of the source elements.</typeparam>
+            <typeparam name="TResult">The type of the result elements.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="evaluator">A function to begin the asynchronous
+            evaluation of each element, the second parameter of which is a
+            <see cref="T:System.Threading.CancellationToken"/> that can be used to abort
+            asynchronous operations.</param>
+            <returns>
+            A sequence query that stream its results as they are
+            evaluated asynchronously.
+            </returns>
+            <remarks>
+            <para>
+            This method uses deferred execution semantics. The results are
+            yielded as each asynchronous evaluation completes and, by default,
+            not guaranteed to be based on the source sequence order. If order
+            is important, compose further with
+            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>.</para>
+            <para>
+            This method starts a new task where the asynchronous evaluations
+            take place and awaited. If the resulting sequence is partially
+            consumed then there's a good chance that some projection work will
+            be wasted and a cooperative effort is done that depends on the
+            <paramref name="evaluator"/> function (via a
+            <see cref="T:System.Threading.CancellationToken"/> as its second argument) to cancel
+            those in flight.</para>
+            <para>
+            The <paramref name="evaluator"/> function should be designed to be
+            thread-agnostic.</para>
+            <para>
+            The task returned by <paramref name="evaluator"/> should be started
+            when the function is called (and not just a mere projection)
+            otherwise changing concurrency options via
+            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>, <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32)"/> or
+            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0})"/> will only change how many
+            tasks are awaited at any given moment, not how many will be
+            kept in flight.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.Task{``1}},System.Func{``0,System.Threading.Tasks.Task{``1},``2})">
+            <summary>
+            Awaits completion of all asynchronous evaluations irrespective of
+            whether they succeed or fail. An additional argument specifies a
+            function that projects the final result given the source item and
+            completed task.
+            </summary>
+            <typeparam name="T">The type of the source elements.</typeparam>
+            <typeparam name="TTaskResult"> The type of the tasks's result.</typeparam>
+            <typeparam name="TResult">The type of the result elements.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="evaluator">A function to begin the asynchronous
+            evaluation of each element, the second parameter of which is a
+            <see cref="T:System.Threading.CancellationToken"/> that can be used to abort
+            asynchronous operations.</param>
+            <param name="resultSelector">A fucntion that projects the final
+            result given the source item and its asynchronous completion
+            result.</param>
+            <returns>
+            A sequence query that stream its results as they are
+            evaluated asynchronously.
+            </returns>
+            <remarks>
+            <para>
+            This method uses deferred execution semantics. The results are
+            yielded as each asynchronous evaluation completes and, by default,
+            not guaranteed to be based on the source sequence order. If order
+            is important, compose further with
+            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>.</para>
+            <para>
+            This method starts a new task where the asynchronous evaluations
+            take place and awaited. If the resulting sequence is partially
+            consumed then there's a good chance that some projection work will
+            be wasted and a cooperative effort is done that depends on the
+            <paramref name="evaluator"/> function (via a
+            <see cref="T:System.Threading.CancellationToken"/> as its second argument) to cancel
+            those in flight.</para>
+            <para>
+            The <paramref name="evaluator"/> function should be designed to be
+            thread-agnostic.</para>
+            <para>
+            The task returned by <paramref name="evaluator"/> should be started
+            when the function is called (and not just a mere projection)
+            otherwise changing concurrency options via
+            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0})"/>, <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32)"/> or
+            <see cref="M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0})"/> will only change how many
+            tasks are awaited at any given moment, not how many will be
+            kept in flight.
+            </para>
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Experimental.ExperimentalEnumerable.Memoize``1(System.Collections.Generic.IEnumerable{``0})">
+            <summary>
+            Creates a sequence that lazily caches the source as it is iterated
+            for the first time, reusing the cache thereafter for future
+            re-iterations. If the source is already cached or buffered then it
+            is returned verbatim.
+            </summary>
+            <typeparam name="T">
+            Type of elements in <paramref name="source"/>.</typeparam>
+            <param name="source">The source sequence.</param>
+            <returns>
+            Returns a sequence that corresponds to a cached version of the
+            input sequence.</returns>
+            <remarks>
+            The returned <see cref="T:System.Collections.Generic.IEnumerable`1"/> will cache items from
+            <paramref name="source"/> in a thread-safe manner. Each thread can
+            call its <see cref="M:System.Collections.Generic.IEnumerable`1.GetEnumerator"/> to acquire an
+            iterator  but the same iterator should not be used simultanesouly
+            from multiple threads. The sequence supplied in
+            <paramref name="source"/> is not expected to be thread-safe but it
+            is required to be thread-agnostic because different threads
+            (though never simultaneously) may iterate over the sequence.
+            </remarks>
+        </member>
+        <member name="T:MoreLinq.Experimental.AwaitQueryOptions">
+            <summary>
+            Represents options for a query whose results evaluate asynchronously.
+            </summary>
+        </member>
+        <member name="F:MoreLinq.Experimental.AwaitQueryOptions.Default">
+            <summary>
+            The default options used for a query whose results evaluate
+            asynchronously.
+            </summary>
+        </member>
+        <member name="P:MoreLinq.Experimental.AwaitQueryOptions.MaxConcurrency">
+            <summary>
+            Gets a positive (non-zero) integer that specifies the maximum
+            number of asynchronous operations to have in-flight concurrently
+            or <c>null</c> to mean unlimited concurrency.
+            </summary>
+        </member>
+        <member name="P:MoreLinq.Experimental.AwaitQueryOptions.Scheduler">
+            <summary>
+            Get the scheduler to be used for any workhorse task.
+            </summary>
+        </member>
+        <member name="P:MoreLinq.Experimental.AwaitQueryOptions.PreserveOrder">
+            <summary>
+            Get a Boolean that determines whether results should be ordered
+            the same as the source.
+            </summary>
+        </member>
+        <member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithMaxConcurrency(System.Nullable{System.Int32})">
+            <summary>
+            Returns new options with the given concurrency limit.
+            </summary>
+            <param name="value">
+            The maximum concurrent asynchronous operation to keep in flight.
+            Use <c>null</c> to mean unbounded concurrency.</param>
+            <returns>Options with the new setting.</returns>
+        </member>
+        <member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithScheduler(System.Threading.Tasks.TaskScheduler)">
+            <summary>
+            Returns new options with the given scheduler.
+            </summary>
+            <param name="value">
+            The scheduler to use to for the workhorse task.</param>
+            <returns>Options with the new setting.</returns>
+        </member>
+        <member name="M:MoreLinq.Experimental.AwaitQueryOptions.WithPreserveOrder(System.Boolean)">
+            <summary>
+            Returns new options with the given Boolean indicating whether or
+            not the results should be returned in the order of the source.
+            </summary>
+            <param name="value">
+            A Boolean where <c>true</c> means results are in source order and
+            <c>false</c> means that results can be delivered in order of
+            efficiency.</param>
+            <returns>Options with the new setting.</returns>
+        </member>
+        <member name="T:MoreLinq.Experimental.IAwaitQuery`1">
+            <summary>
+            Represents a sequence whose elements or results evaluate asynchronously.
+            </summary>
+            <inheritdoc />
+            <typeparam name="T">The type of the source elements.</typeparam>
+        </member>
+        <member name="P:MoreLinq.Experimental.IAwaitQuery`1.Options">
+            <summary>
+            The options that determine how the sequence evaluation behaves when
+            it is iterated.
+            </summary>
+        </member>
+        <member name="M:MoreLinq.Experimental.IAwaitQuery`1.WithOptions(MoreLinq.Experimental.AwaitQueryOptions)">
+            <summary>
+            Returns a new query that will use the given options.
+            </summary>
+            <param name="options">The new options to use.</param>
+            <returns>
+            Returns a new query using the supplied options.
+            </returns>
+        </member>
+        <member name="T:MoreLinq.Extensions.AcquireExtension">
+            <summary><c>Acquire</c> extension.</summary>
+        </member>
+        <member name="M:MoreLinq.Extensions.AcquireExtension.Acquire``1(System.Collections.Generic.IEnumerable{``0})">
+            <summary>
+            Ensures that a source sequence of <see cref="T:System.IDisposable"/>
+            objects are all acquired successfully. If the acquisition of any
+            one <see cref="T:System.IDisposable"/> fails then those successfully
+            acquired till that point are disposed.
+            </summary>
+            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
+            <param name="source">Source sequence of <see cref="T:System.IDisposable"/> objects.</param>
+            <returns>
+            Returns an array of all the acquired <see cref="T:System.IDisposable"/>
+            objects in source order.
+            </returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="T:MoreLinq.Extensions.AggregateExtension">
+            <summary><c>Aggregate</c> extension.</summary>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``4(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},System.Func{``1,``2,``3})">
+            <summary>
+            Applies two accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``5(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},System.Func{``1,``2,``3,``4})">
+            <summary>
+            Applies three accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``6(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},System.Func{``1,``2,``3,``4,``5})">
+            <summary>
+            Applies four accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``7(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},System.Func{``1,``2,``3,``4,``5,``6})">
+            <summary>
+            Applies five accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``8(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},System.Func{``1,``2,``3,``4,``5,``6,``7})">
+            <summary>
+            Applies six accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``9(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},System.Func{``1,``2,``3,``4,``5,``6,``7,``8})">
+            <summary>
+            Applies seven accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="seed7">The seed value for the seventh accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateExtension.Aggregate``10(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},``2,System.Func{``2,``0,``2},``3,System.Func{``3,``0,``3},``4,System.Func{``4,``0,``4},``5,System.Func{``5,``0,``5},``6,System.Func{``6,``0,``6},``7,System.Func{``7,``0,``7},``8,System.Func{``8,``0,``8},System.Func{``1,``2,``3,``4,``5,``6,``7,``8,``9})">
+            <summary>
+            Applies eight accumulators sequentially in a single pass over a
+            sequence.
+            </summary>
+            <typeparam name="T">The type of elements in <paramref name="source"/>.</typeparam>
+            <typeparam name="TAccumulate1">The type of first accumulator value.</typeparam>
+            <typeparam name="TAccumulate2">The type of second accumulator value.</typeparam>
+            <typeparam name="TAccumulate3">The type of third accumulator value.</typeparam>
+            <typeparam name="TAccumulate4">The type of fourth accumulator value.</typeparam>
+            <typeparam name="TAccumulate5">The type of fifth accumulator value.</typeparam>
+            <typeparam name="TAccumulate6">The type of sixth accumulator value.</typeparam>
+            <typeparam name="TAccumulate7">The type of seventh accumulator value.</typeparam>
+            <typeparam name="TAccumulate8">The type of eighth accumulator value.</typeparam>
+            <typeparam name="TResult">The type of the accumulated result.</typeparam>
+            <param name="source">The source sequence</param>
+            <param name="seed1">The seed value for the first accumulator.</param>
+            <param name="accumulator1">The first accumulator.</param>
+            <param name="seed2">The seed value for the second accumulator.</param>
+            <param name="accumulator2">The second accumulator.</param>
+            <param name="seed3">The seed value for the third accumulator.</param>
+            <param name="accumulator3">The third accumulator.</param>
+            <param name="seed4">The seed value for the fourth accumulator.</param>
+            <param name="accumulator4">The fourth accumulator.</param>
+            <param name="seed5">The seed value for the fifth accumulator.</param>
+            <param name="accumulator5">The fifth accumulator.</param>
+            <param name="seed6">The seed value for the sixth accumulator.</param>
+            <param name="accumulator6">The sixth accumulator.</param>
+            <param name="seed7">The seed value for the seventh accumulator.</param>
+            <param name="accumulator7">The seventh accumulator.</param>
+            <param name="seed8">The seed value for the eighth accumulator.</param>
+            <param name="accumulator8">The eighth accumulator.</param>
+            <param name="resultSelector">
+            A function that projects a single result given the result of each
+            accumulator.</param>
+            <returns>The value returned by <paramref name="resultSelector"/>.</returns>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="T:MoreLinq.Extensions.AggregateRightExtension">
+            <summary><c>AggregateRight</c> extension.</summary>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateRightExtension.AggregateRight``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
+            <summary>
+            Applies a right-associative accumulator function over a sequence.
+            This operator is the right-associative version of the
+            <see cref="M:System.Linq.Enumerable.Aggregate``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})"/> LINQ operator.
+            </summary>
+            <typeparam name="TSource">The type of the elements of source.</typeparam>
+            <param name="source">Source sequence.</param>
+            <param name="func">A right-associative accumulator function to be invoked on each element.</param>
+            <returns>The final accumulator value.</returns>
+            <example>
+            <code><![CDATA[
+            string result = Enumerable.Range(1, 5).Select(i => i.ToString()).AggregateRight((a, b) => string.Format("({0}/{1})", a, b));
+            ]]></code>
+            The <c>result</c> variable will contain <c>"(1/(2/(3/(4/5))))"</c>.
+            </example>
+            <remarks>
+            This operator executes immediately.
+            </remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.AggregateRightExtension.AggregateRight``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``0,``1,``1})">
+            <summary>
+            Applies a right-associative accumulator function over a sequence.
+            The specified seed value is used as the initial accumulator value.
+            This operator is the right-associative version of the
+            <see cref="M:System.Linq.Enumerable.Aggregate``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1})"/> LINQ operator.
             </summary>
             <typeparam name="TSource">The type of the elements of source.</typeparam>
             <typeparam name="TAccumulate">The type of the accumulator value.</typeparam>
@@ -5761,7 +6955,12 @@
             <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
             <param name="source">Source sequence.</param>
             <param name="count">Count to assert.</param>
-            <param name="errorSelector">Function that returns the <see cref="T:System.Exception"/> object to throw.</param>
+            <param name="errorSelector">
+            Function that receives a comparison (a negative integer if actual
+            count is less than <paramref name="count"/> and a positive integer
+            if actual count is greater than <paramref name="count"/>) and
+            <paramref name="count"/> as arguments and which returns the
+            <see cref="T:System.Exception"/> object to throw.</param>
             <returns>
             Returns the original sequence as long it is contains the
             number of elements specified by <paramref name="count"/>.
@@ -6390,7 +7589,8 @@
         <member name="M:MoreLinq.Extensions.EquiZipExtension.EquiZip``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -6403,6 +7603,9 @@
             A sequence that contains elements of the two input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -6413,17 +7616,14 @@
             "2B", "3C", "4D" in turn.
             </example>
             <remarks>
-            <para>
-            If the two input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.Extensions.EquiZipExtension.EquiZip``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -6438,6 +7638,9 @@
             A sequence that contains elements of the three input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -6449,16 +7652,14 @@
             "2Bb", "3Cc", "4Dd" in turn.
             </example>
             <remarks>
-            <para>If the three input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.Extensions.EquiZipExtension.EquiZip``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. An exception is thrown
+            if the input sequences are of different lengths.
             </summary>
             <typeparam name="T1">Type of elements in first sequence</typeparam>
             <typeparam name="T2">Type of elements in second sequence</typeparam>
@@ -6475,6 +7676,9 @@
             A sequence that contains elements of the four input sequences,
             combined by <paramref name="resultSelector"/>.
             </returns>
+            <exception cref="T:System.InvalidOperationException">
+            The input sequences are of different lengths.
+            </exception>
             <example>
             <code><![CDATA[
             var numbers = new[] { 1, 2, 3, 4 };
@@ -6487,11 +7691,7 @@
             "2BbFalse", "3CcTrue", "4DdFalse" in turn.
             </example>
             <remarks>
-            <para>
-            If the four input sequences are of different lengths then
-            <see cref="T:System.InvalidOperationException"/> is thrown.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="T:MoreLinq.Extensions.EvaluateExtension">
@@ -6896,8 +8096,33 @@
             and all nested sequences for which the predicate function
             returned <c>true</c>.
             </returns>
-            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null.</exception>
-            <exception cref="T:System.ArgumentNullException"><paramref name="predicate"/> is null.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="source"/> is <c>null</c>.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="predicate"/> is <c>null</c>.</exception>
+        </member>
+        <member name="M:MoreLinq.Extensions.FlattenExtension.Flatten(System.Collections.IEnumerable,System.Func{System.Object,System.Collections.IEnumerable})">
+            <summary>
+            Flattens a sequence containing arbitrarily-nested sequences. An
+            additional parameter specifies a function that projects an inner
+            sequence via a property of an object.
+            </summary>
+            <param name="source">The sequence that will be flattened.</param>
+            <param name="selector">
+            A function that receives each element of the sequence as an object
+            and projects an inner sequence to be flattened. If the function
+            returns <c>null</c> then the object argument is considered a leaf
+            of the flattening process.
+            </param>
+            <returns>
+            A sequence that contains the elements of <paramref name="source"/>
+            and all nested sequences projected via the
+            <paramref name="selector"/> function.
+            </returns>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="source"/> is <c>null</c>.</exception>
+            <exception cref="T:System.ArgumentNullException">
+            <paramref name="selector"/> is <c>null</c>.</exception>
         </member>
         <member name="T:MoreLinq.Extensions.FoldExtension">
             <summary><c>Fold</c> extension.</summary>
@@ -7650,6 +8875,47 @@
             <remarks>This operator uses deferred execution and streams its
             results.</remarks>
         </member>
+        <member name="T:MoreLinq.Extensions.IndexByExtension">
+            <summary><c>IndexBy</c> extension.</summary>
+        </member>
+        <member name="M:MoreLinq.Extensions.IndexByExtension.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
+            <summary>
+            Applies a key-generating function to each element of a sequence and
+            returns a sequence that contains the elements of the original
+            sequence as well its key and index inside the group of its key.
+            </summary>
+            <typeparam name="TSource">Type of the source sequence elements.</typeparam>
+            <typeparam name="TKey">Type of the projected key.</typeparam>
+            <param name="source">Source sequence.</param>
+            <param name="keySelector">
+            Function that projects the key given an element in the source sequence.</param>
+            <returns>
+            A sequence of elements paired with their index within the key-group.
+            The index is the key and the element is the value of the pair.
+            </returns>
+        </member>
+        <member name="M:MoreLinq.Extensions.IndexByExtension.IndexBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
+            <summary>
+            Applies a key-generating function to each element of a sequence and
+            returns a sequence that contains the elements of the original
+            sequence as well its key and index inside the group of its key.
+            An additional parameter specifies a comparer to use for testing the
+            equivalence of keys.
+            </summary>
+            <typeparam name="TSource">Type of the source sequence elements.</typeparam>
+            <typeparam name="TKey">Type of the projected key.</typeparam>
+            <param name="source">Source sequence.</param>
+            <param name="keySelector">
+            Function that projects the key given an element in the source sequence.</param>
+            <param name="comparer">
+            The equality comparer to use to determine whether or not keys are
+            equal. If <c>null</c>, the default equality comparer for
+            <typeparamref name="TSource"/> is used.</param>
+            <returns>
+            A sequence of elements paired with their index within the key-group.
+            The index is the key and the element is the value of the pair.
+            </returns>
+        </member>
         <member name="T:MoreLinq.Extensions.InsertExtension">
             <summary><c>Insert</c> extension.</summary>
         </member>
@@ -8403,7 +9669,9 @@
             <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
             <param name="source">The sequence to pad.</param>
             <param name="width">The width/length below which to pad.</param>
-            <param name="paddingSelector">Function to calculate padding.</param>
+            <param name="paddingSelector">
+            Function to calculate padding given the index of the missing element.
+            </param>
             <returns>
             Returns a sequence that is at least as wide/long as the width/length
             specified by the <paramref name="width"/> parameter.
@@ -8442,11 +9710,11 @@
             </remarks>
             <example>
             <code><![CDATA[
-            int[] numbers = { 123, 456, 789 };
-            var result = numbers.Pairwise((a, b) => a + b);
+            var source = new[] { "a", "b", "c", "d" };
+            var result = source.Pairwise((a, b) => a + b);
             ]]></code>
             The <c>result</c> variable, when iterated over, will yield
-            579 and 1245, in turn.
+            "ab", "bc" and "cd", in turn.
             </example>
         </member>
         <member name="T:MoreLinq.Extensions.PartialSortExtension">
@@ -9170,7 +10438,7 @@
         </member>
         <member name="M:MoreLinq.Extensions.ScanExtension.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
             <summary>
-            Peforms a scan (inclusive prefix sum) on a sequence of elements.
+            Performs a scan (inclusive prefix sum) on a sequence of elements.
             </summary>
             <remarks>
             An inclusive prefix sum returns an equal-length sequence where the
@@ -9218,6 +10486,53 @@
             <param name="transformation">Transformation operation</param>
             <returns>The scanned sequence</returns>
         </member>
+        <member name="T:MoreLinq.Extensions.ScanByExtension">
+            <summary><c>ScanBy</c> extension.</summary>
+        </member>
+        <member name="M:MoreLinq.Extensions.ScanByExtension.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2})">
+            <summary>
+            Applies an accumulator function over sequence element keys,
+            returning the keys along with intermediate accumulator states.
+            </summary>
+            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
+            <typeparam name="TKey">The type of the key.</typeparam>
+            <typeparam name="TState">Type of the state.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="keySelector">
+            A function that returns the key given an element.</param>
+            <param name="seedSelector">
+            A function to determine the initial value for the accumulator that is
+            invoked once per key encountered.</param>
+            <param name="accumulator">
+            An accumulator function invoked for each element.</param>
+            <returns>
+            A sequence of keys paired with intermediate accumulator states.
+            </returns>
+        </member>
+        <member name="M:MoreLinq.Extensions.ScanByExtension.ScanBy``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,``2},System.Func{``2,``1,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
+            <summary>
+            Applies an accumulator function over sequence element keys,
+            returning the keys along with intermediate accumulator states. An
+            additional parameter specifies the comparer to use to compare keys.
+            </summary>
+            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
+            <typeparam name="TKey">The type of the key.</typeparam>
+            <typeparam name="TState">Type of the state.</typeparam>
+            <param name="source">The source sequence.</param>
+            <param name="keySelector">
+            A function that returns the key given an element.</param>
+            <param name="seedSelector">
+            A function to determine the initial value for the accumulator that is
+            invoked once per key encountered.</param>
+            <param name="accumulator">
+            An accumulator function invoked for each element.</param>
+            <param name="comparer">The equality comparer to use to determine
+            whether or not keys are equal. If <c>null</c>, the default equality
+            comparer for <typeparamref name="TSource"/> is used.</param>
+            <returns>
+            A sequence of keys paired with intermediate accumulator states.
+            </returns>
+        </member>
         <member name="T:MoreLinq.Extensions.ScanRightExtension">
             <summary><c>ScanRight</c> extension.</summary>
         </member>
@@ -10703,7 +12018,10 @@
         <member name="M:MoreLinq.Extensions.ZipLongestExtension.ZipLongest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -10726,19 +12044,16 @@
             "2B", "3C", "0D" in turn.
             </example>
             <remarks>
-            <para>
-            If the two input sequences are of different lengths then the result
-            sequence will always be as long as the longer of the two input
-            sequences. The default value of the shorter sequence element type
-            is used for padding.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.Extensions.ZipLongestExtension.ZipLongest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -10764,20 +12079,16 @@
             "2Bb", "3Cc", "0Dd", "0e" in turn.
             </example>
             <remarks>
-            <para>
-            If the input sequences are of different lengths then the result
-            sequence will always be as long as the longest of input sequences.
-            The default value of the each shorter sequence element type is used
-            for padding. This operator uses deferred execution and streams its
-            results.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="M:MoreLinq.Extensions.ZipLongestExtension.ZipLongest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            will always be as long as the longest of input sequences where the
+            default value of each of the shorter sequence element types is used
+            for padding.
             </summary>
             <typeparam name="T1">Type of elements in first sequence</typeparam>
             <typeparam name="T2">Type of elements in second sequence</typeparam>
@@ -10806,13 +12117,7 @@
             "2BbFalse", "3CcTrue", "0DdFalse", "0eTrue", "0\0False" in turn.
             </example>
             <remarks>
-            <para>
-            If the input sequences are of different lengths then the result
-            sequence will always be as long as the longest of input sequences.
-            The default value of the each shorter sequence element type is used
-            for padding.</para>
-            <para>
-            This operator uses deferred execution and streams its results.</para>
+            This operator uses deferred execution and streams its results.
             </remarks>
         </member>
         <member name="T:MoreLinq.Extensions.ZipShortestExtension">
@@ -10820,8 +12125,9 @@
         </member>
         <member name="M:MoreLinq.Extensions.ZipShortestExtension.ZipShortest``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
             <summary>
-            Returns a projection of tuples, where each tuple contains the N-th element
-            from each of the argument sequences.
+            Returns a projection of tuples, where each tuple contains the N-th
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="TFirst">Type of elements in first sequence.</typeparam>
             <typeparam name="TSecond">Type of elements in second sequence.</typeparam>
@@ -10843,9 +12149,10 @@
             </example>
             <remarks>
             <para>
-            If the two input sequences are of different lengths, the result
-            sequence is terminated as soon as the shortest input sequence is
-            exhausted.</para>
+            If the input sequences are of different lengths, the result sequence
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
+            </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
             </remarks>
@@ -10853,7 +12160,8 @@
         <member name="M:MoreLinq.Extensions.ZipShortestExtension.ZipShortest``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element  from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -10880,7 +12188,8 @@
             <remarks>
             <para>
             If the input sequences are of different lengths, the result sequence
-            is terminated as soon as the shortest input sequence is exhausted.
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
             </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
@@ -10889,7 +12198,8 @@
         <member name="M:MoreLinq.Extensions.ZipShortestExtension.ZipShortest``5(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Func{``0,``1,``2,``3,``4})">
             <summary>
             Returns a projection of tuples, where each tuple contains the N-th
-            element from each of the argument sequences.
+            element from each of the argument sequences. The resulting sequence
+            is as short as the shortest input sequence.
             </summary>
             <typeparam name="T1">Type of elements in first sequence.</typeparam>
             <typeparam name="T2">Type of elements in second sequence.</typeparam>
@@ -10919,12 +12229,70 @@
             <remarks>
             <para>
             If the input sequences are of different lengths, the result sequence
-            is terminated as soon as the shortest input sequence is exhausted.
+            is terminated as soon as the shortest input sequence is exhausted
+            and remainder elements from the longer sequences are never consumed.
             </para>
             <para>
             This operator uses deferred execution and streams its results.</para>
             </remarks>
         </member>
+        <member name="T:MoreLinq.Extensions.ToDataTableExtension">
+            <summary><c>ToDataTable</c> extension.</summary>
+        </member>
+        <member name="M:MoreLinq.Extensions.ToDataTableExtension.ToDataTable``1(System.Collections.Generic.IEnumerable{``0})">
+            <summary>
+            Converts a sequence to a <see cref="T:System.Data.DataTable"/> object.
+            </summary>
+            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
+            <param name="source">The source.</param>
+            <returns>
+            A <see cref="T:System.Data.DataTable"/> representing the source.
+            </returns>
+            <remarks>This operator uses immediate execution.</remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.ToDataTableExtension.ToDataTable``1(System.Collections.Generic.IEnumerable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
+            <summary>
+            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/>
+            object with a set of lambda expressions specifying which members (property
+            or field) of each element in the sequence will supply the column values.
+            </summary>
+            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
+            <param name="source">The source.</param>
+            <param name="expressions">Expressions providing access to element members.</param>
+            <returns>
+            A <see cref="T:System.Data.DataTable"/> representing the source.
+            </returns>
+            <remarks>This operator uses immediate execution.</remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.ToDataTableExtension.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1)">
+            <summary>
+            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/> object.
+            </summary>
+            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
+            <typeparam name="TTable"></typeparam>
+            <param name="source">The source.</param>
+            <param name="table"></param>
+            <returns>
+            A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
+            </returns>
+            <remarks>This operator uses immediate execution.</remarks>
+        </member>
+        <member name="M:MoreLinq.Extensions.ToDataTableExtension.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1,System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
+            <summary>
+            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/>
+            object with a set of lambda expressions specifying which members (property
+            or field) of each element in the sequence will supply the column values.
+            </summary>
+            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
+            <typeparam name="TTable">The type of the input and resulting <see cref="T:System.Data.DataTable"/> object.</typeparam>
+            <param name="source">The source.</param>
+            <param name="table">The <see cref="T:System.Data.DataTable"/> type of object where to add rows</param>
+            <param name="expressions">Expressions providing access to element members.</param>
+            <returns>
+            A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
+            </returns>
+            <remarks>This operator uses immediate execution.</remarks>
+        </member>
         <member name="T:MoreLinq.IListLike`1">
             <summary>
             Represents an list-like (indexable) data structure.
@@ -10993,6 +12361,28 @@
             of an item to prepend, an item to append and the source.
             </summary>
         </member>
+        <member name="T:MoreLinq.Reactive.Observable">
+            <summary>
+            Provides a set of static methods for writing in-memory queries over observable sequences.
+            </summary>
+        </member>
+        <member name="M:MoreLinq.Reactive.Observable.Subscribe``1(System.IObservable{``0},System.Action{``0},System.Action{System.Exception},System.Action)">
+            <summary>
+            Subscribes an element handler and a completion handler to an
+            observable sequence.
+            </summary>
+            <typeparam name="T">Type of elements in <paramref name="source"/>.</typeparam>
+            <param name="source">Observable sequence to subscribe to.</param>
+            <param name="onNext">
+            Action to invoke for each element in <paramref name="source"/>.</param>
+            <param name="onError">
+            Action to invoke upon exceptional termination of the
+            <paramref name="source"/>.</param>
+            <param name="onCompleted">
+            Action to invoke upon graceful termination of <paramref name="source"/>.</param>
+            <returns>The subscription, which when disposed, will unsubscribe
+            from <paramref name="source"/>.</returns>
+        </member>
         <member name="T:MoreLinq.SequenceException">
             <summary>
             The exception that is thrown for a sequence that fails a condition.
@@ -11019,5 +12409,13 @@
             <param name="message">A message that describes the error.</param>
             <param name="innerException">The exception that is the cause of the current exception.</param>
         </member>
+        <member name="M:MoreLinq.SequenceException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
+            <summary>
+            Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class
+            with serialized data.
+            </summary>
+            <param name="info">The object that holds the serialized object data.</param>
+            <param name="context">The contextual information about the source or destination.</param>
+        </member>
     </members>
 </doc>
diff --git a/morelinq.3.2.0/morelinq.3.2.0.nupkg b/morelinq.3.2.0/morelinq.3.2.0.nupkg
new file mode 100644
index 0000000..5759971
Binary files /dev/null and b/morelinq.3.2.0/morelinq.3.2.0.nupkg differ