morelinq.3.2.0/lib/netstandard1.0/MoreLinq.xml

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>MoreLinq</name>
    </assembly>
    <members>
        <member name="T:MoreLinq.MoreEnumerable">
            <summary>
            Provides a set of static methods for querying objects that
            implement <see cref="T:System.Collections.Generic.IEnumerable`1" />.
            </summary>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.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="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.
            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.MoreEnumerable.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>
            <param name="source">Source sequence.</param>
            <param name="seed">The initial accumulator value.</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[
            var numbers = Enumerable.Range(1, 5);
            string result = numbers.AggregateRight("6", (a, b) => string.Format("({0}/{1})", a, b));
            ]]></code>
            The <c>result</c> variable will contain <c>"(1/(2/(3/(4/(5/6)))))"</c>.
            </example>
            <remarks>
            This operator executes immediately.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.AggregateRight``3(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``0,``1,``1},System.Func{``1,``2})">
            <summary>
            Applies a right-associative accumulator function over a sequence.
            The specified seed value is used as the initial accumulator value,
            and the specified function is used to select the result value.
            This operator is the right-associative version of the
            <see cref="M:System.Linq.Enumerable.Aggregate``3(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},System.Func{``1,``2})"/> LINQ operator.
            </summary>
            <typeparam name="TSource">The type of the elements of source.</typeparam>
            <typeparam name="TAccumulate">The type of the accumulator value.</typeparam>
            <typeparam name="TResult">The type of the resulting value.</typeparam>
            <param name="source">Source sequence.</param>
            <param name="seed">The initial accumulator value.</param>
            <param name="func">A right-associative accumulator function to be invoked on each element.</param>
            <param name="resultSelector">A function to transform the final accumulator value into the result value.</param>
            <returns>The transformed final accumulator value.</returns>
            <example>
            <code><![CDATA[
            var numbers = Enumerable.Range(1, 5);
            int result = numbers.AggregateRight("6", (a, b) => string.Format("({0}/{1})", a, b), str => str.Length);
            ]]></code>
            The <c>result</c> variable will contain <c>21</c>.
            </example>
            <remarks>
            This operator executes immediately.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Returns a sequence consisting of the head elements and the given tail element.
            </summary>
            <typeparam name="T">Type of sequence</typeparam>
            <param name="head">All elements of the head. Must not be null.</param>
            <param name="tail">Tail element of the new sequence.</param>
            <returns>A sequence consisting of the head elements and the given tail element.</returns>
            <remarks>This operator uses deferred execution and streams its results.</remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Returns a sequence consisting of the head elements and the given tail element.
            </summary>
            <typeparam name="T">Type of sequence</typeparam>
            <param name="head">All elements of the head. Must not be null.</param>
            <param name="tail">Tail element of the new sequence.</param>
            <returns>A sequence consisting of the head elements and the given tail element.</returns>
            <remarks>This operator uses deferred execution and streams its results.</remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Assert``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
            <summary>
            Asserts that all elements of a sequence meet a given condition
            otherwise throws an <see cref="T:System.Exception"/> object.
            </summary>
            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
            <param name="source">Source sequence.</param>
            <param name="predicate">Function that asserts an element of the <paramref name="source"/> sequence for a condition.</param>
            <returns>
            Returns the original sequence.
            </returns>
            <exception cref="T:System.InvalidOperationException">The input sequence
            contains an element that does not meet the condition being
            asserted.</exception>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Assert``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{``0,System.Exception})">
            <summary>
            Asserts that all elements of a sequence meet a given condition
            otherwise throws an <see cref="T:System.Exception"/> object.
            </summary>
            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
            <param name="source">Source sequence.</param>
            <param name="predicate">Function that asserts an element of the input sequence for a condition.</param>
            <param name="errorSelector">Function that returns the <see cref="T:System.Exception"/> object to throw.</param>
            <returns>
            Returns the original sequence.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.AssertCount``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Asserts that a source sequence contains a given count of elements.
            </summary>
            <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>
            <returns>
            Returns the original sequence as long it is contains the
            number of elements specified by <paramref name="count"/>.
            Otherwise it throws <see cref="T:System.Exception" />.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.AssertCount``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Int32,System.Int32,System.Exception})">
            <summary>
            Asserts that a source sequence contains a given count of elements.
            A parameter specifies the exception to be thrown.
            </summary>
            <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 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"/>.
            Otherwise it throws the <see cref="T:System.Exception" /> object
            returned by calling <paramref name="errorSelector"/>.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Backsert``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
            specified index from the tail of the sequence, where zero always
            represents the last position, one represents the second-last
            element, two represents the third-last element and so on.
            </summary>
            <typeparam name="T">
            Type of elements in all sequences.</typeparam>
            <param name="first">The source sequence.</param>
            <param name="second">The sequence that will be inserted.</param>
            <param name="index">
            The zero-based index from the end of <paramref name="first"/> where
            elements from <paramref name="second"/> should be inserted.
            <paramref name="second"/>.</param>
            <returns>
            A sequence that contains the elements of <paramref name="first"/>
            plus the elements of <paramref name="second"/> inserted at
            the given index from the end of <paramref name="first"/>.
            </returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="first"/> is null.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="second"/> is null.</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">
            Thrown if <paramref name="index"/> is negative.
            </exception>
            <exception cref="T:System.ArgumentOutOfRangeException">
            Thrown lazily if <paramref name="index"/> is greater than the
            length of <paramref name="first"/>. The validation occurs when
            the resulting sequence is iterated.
            </exception>
            <remarks>
            This method uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Batch``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Batches the source sequence into sized buckets.
            </summary>
            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="size">Size of buckets.</param>
            <returns>A sequence of equally sized buckets containing elements of the source collection.</returns>
            <remarks>
            This operator uses deferred execution and streams its results (buckets and bucket content).
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
            <summary>
            Batches the source sequence into sized buckets and applies a projection to each bucket.
            </summary>
            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
            <typeparam name="TResult">Type of result returned by <paramref name="resultSelector"/>.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="size">Size of buckets.</param>
            <param name="resultSelector">The projection to apply to each bucket.</param>
            <returns>A sequence of projections on equally sized buckets containing elements of the source collection.</returns>
            <remarks>
            This operator uses deferred execution and streams its results (buckets and bucket content).
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Cartesian``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
            <summary>
            Returns the Cartesian product of two sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Cartesian``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
            <summary>
            Returns the Cartesian product of three sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="T3">
            The type of the elements of <paramref name="third"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="third">The third sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Cartesian``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 the Cartesian product of four sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="T3">
            The type of the elements of <paramref name="third"/>.</typeparam>
            <typeparam name="T4">
            The type of the elements of <paramref name="fourth"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="third">The third sequence of elements.</param>
            <param name="fourth">The fourth sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Cartesian``6(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Func{``0,``1,``2,``3,``4,``5})">
            <summary>
            Returns the Cartesian product of five sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="T3">
            The type of the elements of <paramref name="third"/>.</typeparam>
            <typeparam name="T4">
            The type of the elements of <paramref name="fourth"/>.</typeparam>
            <typeparam name="T5">
            The type of the elements of <paramref name="fifth"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="third">The third sequence of elements.</param>
            <param name="fourth">The fourth sequence of elements.</param>
            <param name="fifth">The fifth sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Cartesian``7(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Collections.Generic.IEnumerable{``5},System.Func{``0,``1,``2,``3,``4,``5,``6})">
            <summary>
            Returns the Cartesian product of six sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="T3">
            The type of the elements of <paramref name="third"/>.</typeparam>
            <typeparam name="T4">
            The type of the elements of <paramref name="fourth"/>.</typeparam>
            <typeparam name="T5">
            The type of the elements of <paramref name="fifth"/>.</typeparam>
            <typeparam name="T6">
            The type of the elements of <paramref name="sixth"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="third">The third sequence of elements.</param>
            <param name="fourth">The fourth sequence of elements.</param>
            <param name="fifth">The fifth sequence of elements.</param>
            <param name="sixth">The sixth sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Cartesian``8(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Collections.Generic.IEnumerable{``5},System.Collections.Generic.IEnumerable{``6},System.Func{``0,``1,``2,``3,``4,``5,``6,``7})">
            <summary>
            Returns the Cartesian product of seven sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="T3">
            The type of the elements of <paramref name="third"/>.</typeparam>
            <typeparam name="T4">
            The type of the elements of <paramref name="fourth"/>.</typeparam>
            <typeparam name="T5">
            The type of the elements of <paramref name="fifth"/>.</typeparam>
            <typeparam name="T6">
            The type of the elements of <paramref name="sixth"/>.</typeparam>
            <typeparam name="T7">
            The type of the elements of <paramref name="seventh"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="third">The third sequence of elements.</param>
            <param name="fourth">The fourth sequence of elements.</param>
            <param name="fifth">The fifth sequence of elements.</param>
            <param name="sixth">The sixth sequence of elements.</param>
            <param name="seventh">The seventh sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Cartesian``9(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Collections.Generic.IEnumerable{``5},System.Collections.Generic.IEnumerable{``6},System.Collections.Generic.IEnumerable{``7},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8})">
            <summary>
            Returns the Cartesian product of eight sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="T3">
            The type of the elements of <paramref name="third"/>.</typeparam>
            <typeparam name="T4">
            The type of the elements of <paramref name="fourth"/>.</typeparam>
            <typeparam name="T5">
            The type of the elements of <paramref name="fifth"/>.</typeparam>
            <typeparam name="T6">
            The type of the elements of <paramref name="sixth"/>.</typeparam>
            <typeparam name="T7">
            The type of the elements of <paramref name="seventh"/>.</typeparam>
            <typeparam name="T8">
            The type of the elements of <paramref name="eighth"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="third">The third sequence of elements.</param>
            <param name="fourth">The fourth sequence of elements.</param>
            <param name="fifth">The fifth sequence of elements.</param>
            <param name="sixth">The sixth sequence of elements.</param>
            <param name="seventh">The seventh sequence of elements.</param>
            <param name="eighth">The eighth sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Choose``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.ValueTuple{System.Boolean,``1}})">
            <summary>
            Applies a function to each element of the source sequence and
            returns a new sequence of result elements for source elements
            where the function returns a couple (2-tuple) having a <c>true</c>
            as its first element and result as the second.
            </summary>
            <typeparam name="T">
            The type of the elements in <paramref name="source"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements in the returned sequence.</typeparam>
            <param name="source"> The source sequence.</param>
            <param name="chooser">The function that is applied to each source
            element.</param>
            <returns>A sequence <typeparamref name="TResult"/> elements.</returns>
            <remarks>
            This method uses deferred execution semantics and streams its
            results.
            </remarks>
            <example>
            <code><![CDATA[
            var str = "O,l,2,3,4,S,6,7,B,9";
            var xs = str.Split(',').Choose(s => (int.TryParse(s, out var n), n));
            ]]></code>
            The <c>xs</c> variable will be a sequence of the integers 2, 3, 4,
            6, 7 and 9.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Consume``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Completely consumes the given sequence. This method uses immediate execution,
            and doesn't store any data during execution.
            </summary>
            <typeparam name="T">Element type of the sequence</typeparam>
            <param name="source">Source to consume</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.CountBy``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 of
            unique keys and their number of occurrences in the original sequence.
            </summary>
            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
            <typeparam name="TKey">Type of the projected element.</typeparam>
            <param name="source">Source sequence.</param>
            <param name="keySelector">Function that transforms each item of source sequence into a key to be compared against the others.</param>
            <returns>A sequence of unique keys and their number of occurrences in the original sequence.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.CountBy``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 of
            unique keys and their number of occurrences in the original sequence.
            An additional argument specifies a comparer to use for testing equivalence of keys.
            </summary>
            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
            <typeparam name="TKey">Type of the projected element.</typeparam>
            <param name="source">Source sequence.</param>
            <param name="keySelector">Function that transforms each item of source sequence into a key to be compared against the others.</param>
            <param name="comparer">The equality comparer to use to determine whether or not keys are equal.
            If null, the default equality comparer for <typeparamref name="TSource"/> is used.</param>
            <returns>A sequence of unique keys and their number of occurrences in the original sequence.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.CountDown``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,System.Nullable{System.Int32},``1})">
            <summary>
            Provides a countdown counter for a given count of elements at the
            tail of the sequence where zero always represents the last element,
            one represents the second-last element, two represents the
            third-last element and so on.
            </summary>
            <typeparam name="T">
            The type of elements of <paramref name="source"/></typeparam>
            <typeparam name="TResult">
            The type of elements of the resulting sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="count">Count of tail elements of
            <paramref name="source"/> to count down.</param>
            <param name="resultSelector">
            A function that receives the element and the current countdown
            value for the element and which returns those mapped to a
            result returned in the resulting sequence. For elements before
            the last <paramref name="count"/>, the coundown value is
            <c>null</c>.</param>
            <returns>
            A sequence of results returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            This method uses deferred execution semantics and streams its
            results. At most, <paramref name="count"/> elements of the source
            sequence may be buffered at any one time unless
            <paramref name="source"/> is a collection or a list.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.AtLeast``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Determines whether or not the number of elements in the sequence is greater than
            or equal to the given integer.
            </summary>
            <typeparam name="T">Element type of sequence</typeparam>
            <param name="source">The source sequence</param>
            <param name="count">The minimum number of items a sequence must have for this
            function to return true</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative</exception>
            <returns><c>true</c> if the number of elements in the sequence is greater than
            or equal to the given integer or <c>false</c> otherwise.</returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 123, 456, 789 };
            var result = numbers.AtLeast(2);
            ]]></code>
            The <c>result</c> variable will contain <c>true</c>.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.AtMost``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Determines whether or not the number of elements in the sequence is lesser than
            or equal to the given integer.
            </summary>
            <typeparam name="T">Element type of sequence</typeparam>
            <param name="source">The source sequence</param>
            <param name="count">The maximun number of items a sequence must have for this
            function to return true</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative</exception>
            <returns><c>true</c> if the number of elements in the sequence is lesser than
            or equal to the given integer or <c>false</c> otherwise.</returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 123, 456, 789 };
            var result = numbers.AtMost(2);
            ]]></code>
            The <c>result</c> variable will contain <c>false</c>.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Exactly``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Determines whether or not the number of elements in the sequence is equals to the given integer.
            </summary>
            <typeparam name="T">Element type of sequence</typeparam>
            <param name="source">The source sequence</param>
            <param name="count">The exactly number of items a sequence must have for this
            function to return true</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative</exception>
            <returns><c>true</c> if the number of elements in the sequence is equals
            to the given integer or <c>false</c> otherwise.</returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 123, 456, 789 };
            var result = numbers.Exactly(3);
            ]]></code>
            The <c>result</c> variable will contain <c>true</c>.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.CountBetween``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Int32)">
            <summary>
            Determines whether or not the number of elements in the sequence is between
            an inclusive range of minimum and maximum integers.
            </summary>
            <typeparam name="T">Element type of sequence</typeparam>
            <param name="source">The source sequence</param>
            <param name="min">The minimum number of items a sequence must have for this
            function to return true</param>
            <param name="max">The maximun number of items a sequence must have for this
            function to return true</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="min"/> is negative or <paramref name="max"/> is less than min</exception>
            <returns><c>true</c> if the number of elements in the sequence is between (inclusive)
            the min and max given integers or <c>false</c> otherwise.</returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 123, 456, 789 };
            var result = numbers.CountBetween(1, 2);
            ]]></code>
            The <c>result</c> variable will contain <c>false</c>.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.CompareCount``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})">
            <summary>
            Compares two sequences and returns an integer that indicates whether the first sequence
            has fewer, the same or more elements than the second sequence.
            </summary>
            <typeparam name="TFirst">Element type of the first sequence</typeparam>
            <typeparam name="TSecond">Element type of the second sequence</typeparam>
            <param name="first">The first sequence</param>
            <param name="second">The second sequence</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="first"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="second"/> is null</exception>
            <returns><c>-1</c> if the first sequence has the fewest elements, <c>0</c> if the two sequences have the same number of elements
            or <c>1</c> if the first sequence has the most elements.</returns>
            <example>
            <code><![CDATA[
            var first = new[] { 123, 456 };
            var second = new[] { 789 };
            var result = first.CompareCount(second);
            ]]></code>
            The <c>result</c> variable will contain <c>1</c>.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Returns all distinct elements of the given source, where "distinctness"
            is determined via a projection and the default equality comparer for the projected type.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results, although
            a set of already-seen keys is retained. If a key is seen multiple times,
            only the first element with that key is returned.
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="keySelector">Projection for determining "distinctness"</param>
            <returns>A sequence consisting of distinct elements from the source sequence,
            comparing them by the specified key projection.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Returns all distinct elements of the given source, where "distinctness"
            is determined via a projection and the specified comparer for the projected type.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results, although
            a set of already-seen keys is retained. If a key is seen multiple times,
            only the first element with that key is returned.
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="keySelector">Projection for determining "distinctness"</param>
            <param name="comparer">The equality comparer to use to determine whether or not keys are equal.
            If null, the default equality comparer for <c>TSource</c> is used.</param>
            <returns>A sequence consisting of distinct elements from the source sequence,
            comparing them by the specified key projection.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.EndsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Determines whether the end of the first sequence is equivalent to
            the second sequence, using the default equality comparer.
            </summary>
            <typeparam name="T">Type of elements.</typeparam>
            <param name="first">The sequence to check.</param>
            <param name="second">The sequence to compare to.</param>
            <returns>
            <c>true</c> if <paramref name="first" /> ends with elements
            equivalent to <paramref name="second" />.
            </returns>
            <remarks>
            This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
            <see cref="M:System.String.EndsWith(System.String)" /> and
            it calls <see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> using
            <see cref="P:System.Collections.Generic.EqualityComparer`1.Default" /> on pairs of elements at
            the same index.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.EndsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Determines whether the end of the first sequence is equivalent to
            the second sequence, using the specified element equality comparer.
            </summary>
            <typeparam name="T">Type of elements.</typeparam>
            <param name="first">The sequence to check.</param>
            <param name="second">The sequence to compare to.</param>
            <param name="comparer">Equality comparer to use.</param>
            <returns>
            <c>true</c> if <paramref name="first" /> ends with elements
            equivalent to <paramref name="second" />.
            </returns>
            <remarks>
            This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
            <see cref="M:System.String.EndsWith(System.String)" /> and it calls
            <see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> on pairs of
            elements at the same index.
            </remarks>
        </member>
        <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. 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>
            <typeparam name="TResult">Type of elements in result sequence.</typeparam>
            <param name="first">The first sequence.</param>
            <param name="second">The second sequence.</param>
            <param name="resultSelector">
            Function to apply to each pair of elements.</param>
            <returns>
            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 };
            var letters = new[] { "A", "B", "C", "D" };
            var zipped = numbers.EquiZip(letters, (n, l) => n + l);
            ]]></code>
            The <c>zipped</c> variable, when iterated over, will yield "1A",
            "2B", "3C", "4D" in turn.
            </example>
            <remarks>
            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. 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>
            <typeparam name="T3">Type of elements in third sequence.</typeparam>
            <typeparam name="TResult">Type of elements in result sequence.</typeparam>
            <param name="first">The first sequence.</param>
            <param name="second">The second sequence.</param>
            <param name="third">The third sequence.</param>
            <param name="resultSelector">
            Function to apply to each triplet of elements.</param>
            <returns>
            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 };
            var letters = new[] { "A", "B", "C", "D" };
            var chars = new[] { 'a', 'b', 'c', 'd' };
            var zipped = numbers.EquiZip(letters, chars, (n, l, c) => n + l + c);
            ]]></code>
            The <c>zipped</c> variable, when iterated over, will yield "1Aa",
            "2Bb", "3Cc", "4Dd" in turn.
            </example>
            <remarks>
            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. 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>
            <typeparam name="T3">Type of elements in third sequence</typeparam>
            <typeparam name="T4">Type of elements in fourth sequence</typeparam>
            <typeparam name="TResult">Type of elements in result sequence</typeparam>
            <param name="first">The first sequence.</param>
            <param name="second">The second sequence.</param>
            <param name="third">The third sequence.</param>
            <param name="fourth">The fourth sequence.</param>
            <param name="resultSelector">
            Function to apply to each quadruplet of elements.</param>
            <returns>
            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 };
            var letters = new[] { "A", "B", "C", "D" };
            var chars = new[] { 'a', 'b', 'c', 'd' };
            var flags = new[] { true, false, true, false };
            var zipped = numbers.EquiZip(letters, chars, flags, (n, l, c, f) => n + l + c + f);
            ]]></code>
            The <c>zipped</c> variable, when iterated over, will yield "1AaTrue",
            "2BbFalse", "3CcTrue", "4DdFalse" in turn.
            </example>
            <remarks>
            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}})">
            <summary>
            Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results.
            If the resulting sequence is enumerated multiple times, the functions will be
            evaluated multiple times too.
            </remarks>
            <typeparam name="T">The type of the object returned by the functions.</typeparam>
            <param name="functions">The functions to evaluate.</param>
            <returns>A sequence with results from invoking <paramref name="functions"/>.</returns>
            <exception cref="T:System.ArgumentNullException">When <paramref name="functions"/> is <c>null</c>.</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ExceptBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Returns the set of elements in the first sequence which aren't
            in the second sequence, according to a given key selector.
            </summary>
            <remarks>
            This is a set operation; if multiple elements in <paramref name="first"/> have
            equal keys, only the first such element is returned.
            This operator uses deferred execution and streams the results, although
            a set of keys from <paramref name="second"/> is immediately selected and retained.
            </remarks>
            <typeparam name="TSource">The type of the elements in the input sequences.</typeparam>
            <typeparam name="TKey">The type of the key returned by <paramref name="keySelector"/>.</typeparam>
            <param name="first">The sequence of potentially included elements.</param>
            <param name="second">The sequence of elements whose keys may prevent elements in
            <paramref name="first"/> from being returned.</param>
            <param name="keySelector">The mapping from source element to key.</param>
            <returns>A sequence of elements from <paramref name="first"/> whose key was not also a key for
            any element in <paramref name="second"/>.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ExceptBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Returns the set of elements in the first sequence which aren't
            in the second sequence, according to a given key selector.
            </summary>
            <remarks>
            This is a set operation; if multiple elements in <paramref name="first"/> have
            equal keys, only the first such element is returned.
            This operator uses deferred execution and streams the results, although
            a set of keys from <paramref name="second"/> is immediately selected and retained.
            </remarks>
            <typeparam name="TSource">The type of the elements in the input sequences.</typeparam>
            <typeparam name="TKey">The type of the key returned by <paramref name="keySelector"/>.</typeparam>
            <param name="first">The sequence of potentially included elements.</param>
            <param name="second">The sequence of elements whose keys may prevent elements in
            <paramref name="first"/> from being returned.</param>
            <param name="keySelector">The mapping from source element to key.</param>
            <param name="keyComparer">The equality comparer to use to determine whether or not keys are equal.
            If null, the default equality comparer for <c>TSource</c> is used.</param>
            <returns>A sequence of elements from <paramref name="first"/> whose key was not also a key for
            any element in <paramref name="second"/>.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Exclude``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Int32)">
            <summary>
            Excludes a contiguous number of elements from a sequence starting
            at a given index.
            </summary>
            <typeparam name="T">The type of the elements of the sequence</typeparam>
            <param name="sequence">The sequence to exclude elements from</param>
            <param name="startIndex">The zero-based index at which to begin excluding elements</param>
            <param name="count">The number of elements to exclude</param>
            <returns>A sequence that excludes the specified portion of elements</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Returns the elements of the specified sequence or the specified
            value in a singleton collection if the sequence is empty.
            </summary>
            <typeparam name="T">The type of the elements in the sequences.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="fallback">The value to return in a singleton
            collection if <paramref name="source"/> is empty.</param>
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains <paramref name="fallback"/>
            if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
            </returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 123, 456, 789 };
            var result = numbers.Where(x => x == 100).FallbackIfEmpty(-1).Single();
            ]]></code>
            The <c>result</c> variable will contain <c>-1</c>.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0,``0)">
            <summary>
            Returns the elements of a sequence, but if it is empty then
            returns an alternate sequence of values.
            </summary>
            <typeparam name="T">The type of the elements in the sequences.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="fallback1">First value of the alternate sequence that
            is returned if <paramref name="source"/> is empty.</param>
            <param name="fallback2">Second value of the alternate sequence that
            is returned if <paramref name="source"/> is empty.</param>
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
            if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0,``0,``0)">
            <summary>
            Returns the elements of a sequence, but if it is empty then
            returns an alternate sequence of values.
            </summary>
            <typeparam name="T">The type of the elements in the sequences.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="fallback1">First value of the alternate sequence that
            is returned if <paramref name="source"/> is empty.</param>
            <param name="fallback2">Second value of the alternate sequence that
            is returned if <paramref name="source"/> is empty.</param>
            <param name="fallback3">Third value of the alternate sequence that
            is returned if <paramref name="source"/> is empty.</param>
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
            if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0,``0,``0,``0)">
            <summary>
            Returns the elements of a sequence, but if it is empty then
            returns an alternate sequence of values.
            </summary>
            <typeparam name="T">The type of the elements in the sequences.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="fallback1">First value of the alternate sequence that
            is returned if <paramref name="source"/> is empty.</param>
            <param name="fallback2">Second value of the alternate sequence that
            is returned if <paramref name="source"/> is empty.</param>
            <param name="fallback3">Third value of the alternate sequence that
            is returned if <paramref name="source"/> is empty.</param>
            <param name="fallback4">Fourth value of the alternate sequence that
            is returned if <paramref name="source"/> is empty.</param>
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
            if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},``0[])">
            <summary>
            Returns the elements of a sequence, but if it is empty then
            returns an alternate sequence from an array of values.
            </summary>
            <typeparam name="T">The type of the elements in the sequences.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="fallback">The array that is returned as the alternate
            sequence if <paramref name="source"/> is empty.</param>
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
            if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FallbackIfEmpty``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Returns the elements of a sequence, but if it is empty then
            returns an alternate sequence of values.
            </summary>
            <typeparam name="T">The type of the elements in the sequences.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="fallback">The alternate sequence that is returned
            if <paramref name="source"/> is empty.</param>
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that containing fallback values
            if <paramref name="source"/> is empty; otherwise, <paramref name="source"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FillBackward``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Returns a sequence with each null reference or value in the source
            replaced with the following non-null reference or value in
            that sequence.
            </summary>
            <param name="source">The source sequence.</param>
            <typeparam name="T">Type of the elements in the source sequence.</typeparam>
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with null references or values
            replaced.
            </returns>
            <remarks>
            This method uses deferred execution semantics and streams its
            results. If references or values are null at the end of the
            sequence then they remain null.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FillBackward``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns a sequence with each missing element in the source replaced
            with the following non-missing element in that sequence. An
            additional parameter specifies a function used to determine if an
            element is considered missing or not.
            </summary>
            <param name="source">The source sequence.</param>
            <param name="predicate">The function used to determine if
            an element in the sequence is considered missing.</param>
            <typeparam name="T">Type of the elements in the source sequence.</typeparam>
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing values replaced.
            </returns>
            <remarks>
            This method uses deferred execution semantics and streams its
            results. If elements are missing at the end of the sequence then
            they remain missing.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FillBackward``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{``0,``0,``0})">
            <summary>
            Returns a sequence with each missing element in the source replaced
            with the following non-missing element in that sequence. Additional
            parameters specifiy two functions, one used to determine if an
            element is considered missing or not and another to provide the
            replacement for the missing element.
            </summary>
            <param name="source">The source sequence.</param>
            <param name="predicate">The function used to determine if
            an element in the sequence is considered missing.</param>
            <param name="fillSelector">The function used to produce the element
            that will replace the missing one. Its first argument receives the
            current element considered missing while the second argument
            receives the next non-missing element.</param>
            <typeparam name="T">Type of the elements in the source sequence.</typeparam>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing values replaced.
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing elements filled.
            </returns>
            <remarks>
            This method uses deferred execution semantics and streams its
            results. If elements are missing at the end of the sequence then
            they remain missing.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FillForward``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Returns a sequence with each null reference or value in the source
            replaced with the previous non-null reference or value seen in
            that sequence.
            </summary>
            <param name="source">The source sequence.</param>
            <typeparam name="T">Type of the elements in the source sequence.</typeparam>
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with null references or values
            replaced.
            </returns>
            <remarks>
            This method uses deferred execution semantics and streams its
            results. If references or values are null at the start of the
            sequence then they remain null.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FillForward``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns a sequence with each missing element in the source replaced
            with the previous non-missing element seen in that sequence. An
            additional parameter specifies a function used to determine if an
            element is considered missing or not.
            </summary>
            <param name="source">The source sequence.</param>
            <param name="predicate">The function used to determine if
            an element in the sequence is considered missing.</param>
            <typeparam name="T">Type of the elements in the source sequence.</typeparam>
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing values replaced.
            </returns>
            <remarks>
            This method uses deferred execution semantics and streams its
            results. If elements are missing at the start of the sequence then
            they remain missing.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FillForward``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{``0,``0,``0})">
            <summary>
            Returns a sequence with each missing element in the source replaced
            with one based on the previous non-missing element seen in that
            sequence. Additional parameters specifiy two functions, one used to
            determine if an element is considered missing or not and another
            to provide the replacement for the missing element.
            </summary>
            <param name="source">The source sequence.</param>
            <param name="predicate">The function used to determine if
            an element in the sequence is considered missing.</param>
            <param name="fillSelector">The function used to produce the element
            that will replace the missing one. Its first argument receives the
            current element considered missing while the second argument
            receives the previous non-missing element.</param>
            <typeparam name="T">Type of the elements in the source sequence.</typeparam>
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> with missing values replaced.
            </returns>
            <remarks>
            This method uses deferred execution semantics and streams its
            results. If elements are missing at the start of the sequence then
            they remain missing.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Flatten(System.Collections.IEnumerable)">
            <summary>
            Flattens a sequence containing arbitrarily-nested sequences.
            </summary>
            <param name="source">The sequence that will be flattened.</param>
            <returns>
            A sequence that contains the elements of <paramref name="source"/>
            and all nested sequences (except strings).
            </returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null.</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Flatten(System.Collections.IEnumerable,System.Func{System.Collections.IEnumerable,System.Boolean})">
            <summary>
            Flattens a sequence containing arbitrarily-nested sequences. An
            additional parameter specifies a predicate function used to
            determine whether a nested <see cref="T:System.Collections.IEnumerable"/> should be
            flattened or not.
            </summary>
            <param name="source">The sequence that will be flattened.</param>
            <param name="predicate">
            A function that receives each element that implements
            <see cref="T:System.Collections.IEnumerable"/> and indicates if its elements should be
            recursively flattened into the resulting sequence.
            </param>
            <returns>
            A sequence that contains the elements of <paramref name="source"/>
            and all nested sequences for which the predicate function
            returned <c>true</c>.
            </returns>
            <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>
            Returns the result of applying a function to a sequence of
            1 element.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 1 element</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            2 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 2 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            3 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 3 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            4 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 4 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            5 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 5 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            6 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 6 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            7 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 7 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            8 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 8 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            9 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 9 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            10 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 10 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            11 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 11 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            12 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 12 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            13 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 13 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            14 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 14 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            15 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 15 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Fold``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``0,``1})">
            <summary>
            Returns the result of applying a function to a sequence of
            16 elements.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers
            as many items of the source sequence as necessary.
            </remarks>
            <typeparam name="T">Type of element in the source sequence</typeparam>
            <typeparam name="TResult">Type of the result</typeparam>
            <param name="source">The sequence of items to fold.</param>
            <param name="folder">Function to apply to the elements in the sequence.</param>
            <returns>The folded value returned by <paramref name="folder"/>.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="folder"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> does not contain exactly 16 elements</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})">
            <summary>
            Immediately executes the given action on each element in the source sequence.
            </summary>
            <typeparam name="T">The type of the elements in the sequence</typeparam>
            <param name="source">The sequence of elements</param>
            <param name="action">The action to execute on each element</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ForEach``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0,System.Int32})">
            <summary>
            Immediately executes the given action on each element in the source sequence.
            Each element's index is used in the logic of the action.
            </summary>
            <typeparam name="T">The type of the elements in the sequence</typeparam>
            <param name="source">The sequence of elements</param>
            <param name="action">The action to execute on each element; the second parameter
            of the action represents the index of the source element.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.From``1(System.Func{``0})">
            <summary>
            Returns a single-element sequence containing the result of invoking the function.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results.
            If the resulting sequence is enumerated multiple times, the function will be
            invoked multiple times too.
            </remarks>
            <typeparam name="T">The type of the object returned by the function.</typeparam>
            <param name="function">The function to evaluate.</param>
            <returns>A sequence with the value resulting from invoking <paramref name="function"/>.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.From``1(System.Func{``0},System.Func{``0})">
            <summary>
            Returns a sequence containing the result of invoking each parameter function in order.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results.
            If the resulting sequence is enumerated multiple times, the functions will be
            invoked multiple times too.
            </remarks>
            <typeparam name="T">The type of the object returned by the functions.</typeparam>
            <param name="function1">The first function to evaluate.</param>
            <param name="function2">The second function to evaluate.</param>
            <returns>A sequence with the values resulting from invoking <paramref name="function1"/> and <paramref name="function2"/>.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.From``1(System.Func{``0},System.Func{``0},System.Func{``0})">
            <summary>
            Returns a sequence containing the result of invoking each parameter function in order.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results.
            If the resulting sequence is enumerated multiple times, the functions will be
            invoked multiple times too.
            </remarks>
            <typeparam name="T">The type of the object returned by the functions.</typeparam>
            <param name="function1">The first function to evaluate.</param>
            <param name="function2">The second function to evaluate.</param>
            <param name="function3">The third function to evaluate.</param>
            <returns>A sequence with the values resulting from invoking <paramref name="function1"/>, <paramref name="function2"/> and <paramref name="function3"/>.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.From``1(System.Func{``0}[])">
            <summary>
            Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results.
            If the resulting sequence is enumerated multiple times, the functions will be
            invoked multiple times too.
            </remarks>
            <typeparam name="T">The type of the object returned by the functions.</typeparam>
            <param name="functions">The functions to evaluate.</param>
            <returns>A sequence with the values resulting from invoking all of the <paramref name="functions"/>.</returns>
            <exception cref="T:System.ArgumentNullException">When <paramref name="functions"/> is <c>null</c>.</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FullGroupJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2})">
            <summary>
            Performs a Full Group Join between the <paramref name="first"/> and <paramref name="second"/> sequences.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results.
            The results are yielded in the order of the elements found in the first sequence
            followed by those found only in the second. In addition, the callback responsible
            for projecting the results is supplied with sequences which preserve their source order.
            </remarks>
            <typeparam name="TFirst">The type of the elements in the first input sequence</typeparam>
            <typeparam name="TSecond">The type of the elements in the second input sequence</typeparam>
            <typeparam name="TKey">The type of the key to use to join</typeparam>
            <param name="first">First sequence</param>
            <param name="second">Second sequence</param>
            <param name="firstKeySelector">The mapping from first sequence to key</param>
            <param name="secondKeySelector">The mapping from second sequence to key</param>
            <returns>A sequence of elements joined from <paramref name="first"/> and <paramref name="second"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FullGroupJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Collections.Generic.IEqualityComparer{``2})">
            <summary>
            Performs a Full Group Join between the <paramref name="first"/> and <paramref name="second"/> sequences.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results.
            The results are yielded in the order of the elements found in the first sequence
            followed by those found only in the second. In addition, the callback responsible
            for projecting the results is supplied with sequences which preserve their source order.
            </remarks>
            <typeparam name="TFirst">The type of the elements in the first input sequence</typeparam>
            <typeparam name="TSecond">The type of the elements in the second input sequence</typeparam>
            <typeparam name="TKey">The type of the key to use to join</typeparam>
            <param name="first">First sequence</param>
            <param name="second">Second sequence</param>
            <param name="firstKeySelector">The mapping from first sequence to key</param>
            <param name="secondKeySelector">The mapping from second sequence to key</param>
            <param name="comparer">The equality comparer to use to determine whether or not keys are equal.
            If null, the default equality comparer for <c>TKey</c> is used.</param>
            <returns>A sequence of elements joined from <paramref name="first"/> and <paramref name="second"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FullGroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``2,System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},``3})">
            <summary>
            Performs a full group-join between two sequences.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results.
            The results are yielded in the order of the elements found in the first sequence
            followed by those found only in the second. In addition, the callback responsible
            for projecting the results is supplied with sequences which preserve their source order.
            </remarks>
            <typeparam name="TFirst">The type of the elements in the first input sequence</typeparam>
            <typeparam name="TSecond">The type of the elements in the second input sequence</typeparam>
            <typeparam name="TKey">The type of the key to use to join</typeparam>
            <typeparam name="TResult">The type of the elements of the resulting sequence</typeparam>
            <param name="first">First sequence</param>
            <param name="second">Second sequence</param>
            <param name="firstKeySelector">The mapping from first sequence to key</param>
            <param name="secondKeySelector">The mapping from second sequence to key</param>
            <param name="resultSelector">Function to apply to each pair of elements plus the key</param>
            <returns>A sequence of elements joined from <paramref name="first"/> and <paramref name="second"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FullGroupJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``2,System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},``3},System.Collections.Generic.IEqualityComparer{``2})">
            <summary>
            Performs a full group-join between two sequences.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results.
            The results are yielded in the order of the elements found in the first sequence
            followed by those found only in the second. In addition, the callback responsible
            for projecting the results is supplied with sequences which preserve their source order.
            </remarks>
            <typeparam name="TFirst">The type of the elements in the first input sequence</typeparam>
            <typeparam name="TSecond">The type of the elements in the second input sequence</typeparam>
            <typeparam name="TKey">The type of the key to use to join</typeparam>
            <typeparam name="TResult">The type of the elements of the resulting sequence</typeparam>
            <param name="first">First sequence</param>
            <param name="second">Second sequence</param>
            <param name="firstKeySelector">The mapping from first sequence to key</param>
            <param name="secondKeySelector">The mapping from second sequence to key</param>
            <param name="resultSelector">Function to apply to each pair of elements plus the key</param>
            <param name="comparer">The equality comparer to use to determine whether or not keys are equal.
            If null, the default equality comparer for <c>TKey</c> is used.</param>
            <returns>A sequence of elements joined from <paramref name="first"/> and <paramref name="second"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FullJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``2},System.Func{``0,``0,``2})">
            <summary>
            Performs a full outer join on two homogeneous sequences.
            Additional arguments specify key selection functions and result
            projection functions.
            </summary>
            <typeparam name="TSource">
            The type of elements in the source sequence.</typeparam>
            <typeparam name="TKey">
            The type of the key returned by the key selector function.</typeparam>
            <typeparam name="TResult">
            The type of the result elements.</typeparam>
            <param name="first">
            The first sequence to join fully.</param>
            <param name="second">
            The second sequence to join fully.</param>
            <param name="keySelector">
            Function that projects the key given an element of one of the
            sequences to join.</param>
            <param name="firstSelector">
            Function that projects the result given just an element from
            <paramref name="first"/> where there is no corresponding element
            in <paramref name="second"/>.</param>
            <param name="secondSelector">
            Function that projects the result given just an element from
            <paramref name="second"/> where there is no corresponding element
            in <paramref name="first"/>.</param>
            <param name="bothSelector">
            Function that projects the result given an element from
            <paramref name="first"/> and an element from <paramref name="second"/>
            that match on a common key.</param>
            <returns>A sequence containing results projected from a full
            outer join of the two input sequences.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FullJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``2},System.Func{``0,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Performs a full outer join on two homogeneous sequences.
            Additional arguments specify key selection functions, result
            projection functions and a key comparer.
            </summary>
            <typeparam name="TSource">
            The type of elements in the source sequence.</typeparam>
            <typeparam name="TKey">
            The type of the key returned by the key selector function.</typeparam>
            <typeparam name="TResult">
            The type of the result elements.</typeparam>
            <param name="first">
            The first sequence to join fully.</param>
            <param name="second">
            The second sequence to join fully.</param>
            <param name="keySelector">
            Function that projects the key given an element of one of the
            sequences to join.</param>
            <param name="firstSelector">
            Function that projects the result given just an element from
            <paramref name="first"/> where there is no corresponding element
            in <paramref name="second"/>.</param>
            <param name="secondSelector">
            Function that projects the result given just an element from
            <paramref name="second"/> where there is no corresponding element
            in <paramref name="first"/>.</param>
            <param name="bothSelector">
            Function that projects the result given an element from
            <paramref name="first"/> and an element from <paramref name="second"/>
            that match on a common key.</param>
            <param name="comparer">
            The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
            keys for equality.</param>
            <returns>A sequence containing results projected from a full
            outer join of the two input sequences.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FullJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``1,``3},System.Func{``0,``1,``3})">
            <summary>
            Performs a full outer join on two heterogeneous sequences.
            Additional arguments specify key selection functions and result
            projection functions.
            </summary>
            <typeparam name="TFirst">
            The type of elements in the first sequence.</typeparam>
            <typeparam name="TSecond">
            The type of elements in the second sequence.</typeparam>
            <typeparam name="TKey">
            The type of the key returned by the key selector functions.</typeparam>
            <typeparam name="TResult">
            The type of the result elements.</typeparam>
            <param name="first">
            The first sequence to join fully.</param>
            <param name="second">
            The second sequence to join fully.</param>
            <param name="firstKeySelector">
            Function that projects the key given an element from <paramref name="first"/>.</param>
            <param name="secondKeySelector">
            Function that projects the key given an element from <paramref name="second"/>.</param>
            <param name="firstSelector">
            Function that projects the result given just an element from
            <paramref name="first"/> where there is no corresponding element
            in <paramref name="second"/>.</param>
            <param name="secondSelector">
            Function that projects the result given just an element from
            <paramref name="second"/> where there is no corresponding element
            in <paramref name="first"/>.</param>
            <param name="bothSelector">
            Function that projects the result given an element from
            <paramref name="first"/> and an element from <paramref name="second"/>
            that match on a common key.</param>
            <returns>A sequence containing results projected from a full
            outer join of the two input sequences.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FullJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``1,``3},System.Func{``0,``1,``3},System.Collections.Generic.IEqualityComparer{``2})">
            <summary>
            Performs a full outer join on two heterogeneous sequences.
            Additional arguments specify key selection functions, result
            projection functions and a key comparer.
            </summary>
            <typeparam name="TFirst">
            The type of elements in the first sequence.</typeparam>
            <typeparam name="TSecond">
            The type of elements in the second sequence.</typeparam>
            <typeparam name="TKey">
            The type of the key returned by the key selector functions.</typeparam>
            <typeparam name="TResult">
            The type of the result elements.</typeparam>
            <param name="first">
            The first sequence to join fully.</param>
            <param name="second">
            The second sequence to join fully.</param>
            <param name="firstKeySelector">
            Function that projects the key given an element from <paramref name="first"/>.</param>
            <param name="secondKeySelector">
            Function that projects the key given an element from <paramref name="second"/>.</param>
            <param name="firstSelector">
            Function that projects the result given just an element from
            <paramref name="first"/> where there is no corresponding element
            in <paramref name="second"/>.</param>
            <param name="secondSelector">
            Function that projects the result given just an element from
            <paramref name="second"/> where there is no corresponding element
            in <paramref name="first"/>.</param>
            <param name="bothSelector">
            Function that projects the result given an element from
            <paramref name="first"/> and an element from <paramref name="second"/>
            that match on a common key.</param>
            <param name="comparer">
            The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
            keys for equality.</param>
            <returns>A sequence containing results projected from a full
            outer join of the two input sequences.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Generate``1(``0,System.Func{``0,``0})">
            <summary>
            Returns a sequence of values consecutively generated by a generator function.
            </summary>
            <typeparam name="TResult">Type of elements to generate.</typeparam>
            <param name="initial">Value of first element in sequence</param>
            <param name="generator">
            Generator function which takes the previous series element and uses it to generate the next element.
            </param>
            <returns>A sequence containing the generated values.</returns>
            <remarks>
            This function defers element generation until needed and streams the results.
            </remarks>
            <example>
            <code><![CDATA[
            var result = MoreEnumerable.Generate(2, n => n * n).Take(5);
            ]]></code>
            The <c>result</c> variable, when iterated over, will yield 2, 4, 16, 256, and 65536, in turn.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.GenerateByIndex``1(System.Func{System.Int32,``0})">
            <summary>
            Returns a sequence of values based on indexes.
            </summary>
            <typeparam name="TResult">
            The type of the value returned by <paramref name="generator"/>
            and therefore the elements of the generated sequence.</typeparam>
            <param name="generator">
            Generation function to apply to each index.</param>
            <returns>A sequence of generated results.</returns>
            <remarks>
            <para>
            The sequence is (practically) infinite where the index ranges from
            zero to <see cref="F:System.Int32.MaxValue"/> inclusive.</para>
            <para>
            This function defers execution and streams the results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.GroupAdjacent``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Groups the adjacent elements of a sequence according to a
            specified key selector function.
            </summary>
            <typeparam name="TSource">The type of the elements of
            <paramref name="source"/>.</typeparam>
            <typeparam name="TKey">The type of the key returned by
            <paramref name="keySelector"/>.</typeparam>
            <param name="source">A sequence whose elements to group.</param>
            <param name="keySelector">A function to extract the key for each
            element.</param>
            <returns>A sequence of groupings where each grouping
            (<see cref="T:System.Linq.IGrouping`2"/>) contains the key
            and the adjacent elements in the same order as found in the
            source sequence.</returns>
            <remarks>
            This method is implemented by using deferred execution and
            streams the groupings. The grouping elements, however, are
            buffered. Each grouping is therefore yielded as soon as it
            is complete and before the next grouping occurs.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.GroupAdjacent``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Groups the adjacent elements of a sequence according to a
            specified key selector function and compares the keys by using a
            specified comparer.
            </summary>
            <typeparam name="TSource">The type of the elements of
            <paramref name="source"/>.</typeparam>
            <typeparam name="TKey">The type of the key returned by
            <paramref name="keySelector"/>.</typeparam>
            <param name="source">A sequence whose elements to group.</param>
            <param name="keySelector">A function to extract the key for each
            element.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> to
            compare keys.</param>
            <returns>A sequence of groupings where each grouping
            (<see cref="T:System.Linq.IGrouping`2"/>) contains the key
            and the adjacent elements in the same order as found in the
            source sequence.</returns>
            <remarks>
            This method is implemented by using deferred execution and
            streams the groupings. The grouping elements, however, are
            buffered. Each grouping is therefore yielded as soon as it
            is complete and before the next grouping occurs.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.GroupAdjacent``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2})">
            <summary>
            Groups the adjacent elements of a sequence according to a
            specified key selector function and projects the elements for
            each group by using a specified function.
            </summary>
            <typeparam name="TSource">The type of the elements of
            <paramref name="source"/>.</typeparam>
            <typeparam name="TKey">The type of the key returned by
            <paramref name="keySelector"/>.</typeparam>
            <typeparam name="TElement">The type of the elements in the
            resulting groupings.</typeparam>
            <param name="source">A sequence whose elements to group.</param>
            <param name="keySelector">A function to extract the key for each
            element.</param>
            <param name="elementSelector">A function to map each source
            element to an element in the resulting grouping.</param>
            <returns>A sequence of groupings where each grouping
            (<see cref="T:System.Linq.IGrouping`2"/>) contains the key
            and the adjacent elements (of type <typeparamref name="TElement"/>)
            in the same order as found in the source sequence.</returns>
            <remarks>
            This method is implemented by using deferred execution and
            streams the groupings. The grouping elements, however, are
            buffered. Each grouping is therefore yielded as soon as it
            is complete and before the next grouping occurs.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.GroupAdjacent``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Groups the adjacent elements of a sequence according to a
            specified key selector function. The keys are compared by using
            a comparer and each group's elements are projected by using a
            specified function.
            </summary>
            <typeparam name="TSource">The type of the elements of
            <paramref name="source"/>.</typeparam>
            <typeparam name="TKey">The type of the key returned by
            <paramref name="keySelector"/>.</typeparam>
            <typeparam name="TElement">The type of the elements in the
            resulting groupings.</typeparam>
            <param name="source">A sequence whose elements to group.</param>
            <param name="keySelector">A function to extract the key for each
            element.</param>
            <param name="elementSelector">A function to map each source
            element to an element in the resulting grouping.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> to
            compare keys.</param>
            <returns>A sequence of groupings where each grouping
            (<see cref="T:System.Linq.IGrouping`2"/>) contains the key
            and the adjacent elements (of type <typeparamref name="TElement"/>)
            in the same order as found in the source sequence.</returns>
            <remarks>
            This method is implemented by using deferred execution and
            streams the groupings. The grouping elements, however, are
            buffered. Each grouping is therefore yielded as soon as it
            is complete and before the next grouping occurs.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.GroupAdjacent``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,System.Collections.Generic.IEnumerable{``0},``2})">
            <summary>
            Groups the adjacent elements of a sequence according to a
            specified key selector function. The keys are compared by using
            a comparer and each group's elements are projected by using a
            specified function.
            </summary>
            <typeparam name="TSource">The type of the elements of
            <paramref name="source"/>.</typeparam>
            <typeparam name="TKey">The type of the key returned by
            <paramref name="keySelector"/>.</typeparam>
            <typeparam name="TResult">The type of the elements in the
            resulting sequence.</typeparam>
            <param name="source">A sequence whose elements to group.</param>
            <param name="keySelector">A function to extract the key for each
            element.</param>
            <param name="resultSelector">A function to map each key and
            associated source elements to a result object.</param>
            <returns>A collection of elements of type
            <typeparamref name="TResult" /> where each element represents
            a projection over a group and its key.</returns>
            <remarks>
            This method is implemented by using deferred execution and
            streams the groupings. The grouping elements, however, are
            buffered. Each grouping is therefore yielded as soon as it
            is complete and before the next grouping occurs.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.GroupAdjacent``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``1,System.Collections.Generic.IEnumerable{``0},``2},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Groups the adjacent elements of a sequence according to a
            specified key selector function. The keys are compared by using
            a comparer and each group's elements are projected by using a
            specified function.
            </summary>
            <typeparam name="TSource">The type of the elements of
            <paramref name="source"/>.</typeparam>
            <typeparam name="TKey">The type of the key returned by
            <paramref name="keySelector"/>.</typeparam>
            <typeparam name="TResult">The type of the elements in the
            resulting sequence.</typeparam>
            <param name="source">A sequence whose elements to group.</param>
            <param name="keySelector">A function to extract the key for each
            element.</param>
            <param name="resultSelector">A function to map each key and
            associated source elements to a result object.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> to
            compare keys.</param>
            <returns>A collection of elements of type
            <typeparamref name="TResult" /> where each element represents
            a projection over a group and its key.</returns>
            <remarks>
            This method is implemented by using deferred execution and
            streams the groupings. The grouping elements, however, are
            buffered. Each grouping is therefore yielded as soon as it
            is complete and before the next grouping occurs.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Index``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Returns a sequence of <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
            where the key is the zero-based index of the value in the source
            sequence.
            </summary>
            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <returns>A sequence of <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.</returns>
            <remarks>This operator uses deferred execution and streams its
            results.</remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Index``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Returns a sequence of <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
            where the key is the index of the value in the source sequence.
            An additional parameter specifies the starting index.
            </summary>
            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="startIndex"></param>
            <returns>A sequence of <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.</returns>
            <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
            specified index.
            </summary>
            <typeparam name="T">Type of the elements of the source sequence.</typeparam>
            <param name="first">The source sequence.</param>
            <param name="second">The sequence that will be inserted.</param>
            <param name="index">
            The zero-based index at which to insert elements from
            <paramref name="second"/>.</param>
            <returns>
            A sequence that contains the elements of <paramref name="first"/>
            plus the elements of <paramref name="second"/> inserted at
            the given index.
            </returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="first"/> is null.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="second"/> is null.</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">
            Thrown if <paramref name="index"/> is negative.
            </exception>
            <exception cref="T:System.ArgumentOutOfRangeException">
            Thrown lazily if <paramref name="index"/> is greater than the
            length of <paramref name="first"/>. The validation occurs when
            yielding the next element after having iterated
            <paramref name="first"/> entirely.
            </exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Interleave``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0}[])">
            <summary>
            Interleaves the elements of two or more sequences into a single sequence, skipping sequences as they are consumed
            </summary>
            <remarks>
            Interleave combines sequences by visiting each in turn, and returning the first element of each, followed
            by the second, then the third, and so on. So, for example:<br/>
            <code><![CDATA[
            {1,1,1}.Interleave( {2,2,2}, {3,3,3} ) => { 1,2,3,1,2,3,1,2,3 }
            ]]></code>
            This operator behaves in a deferred and streaming manner.<br/>
            When sequences are of unequal length, this method will skip those sequences that have been fully consumed
            and continue interleaving the remaining sequences.<br/>
            The sequences are interleaved in the order that they appear in the <paramref name="otherSequences"/>
            collection, with <paramref name="sequence"/> as the first sequence.
            </remarks>
            <typeparam name="T">The type of the elements of the source sequences</typeparam>
            <param name="sequence">The first sequence in the interleave group</param>
            <param name="otherSequences">The other sequences in the interleave group</param>
            <returns>A sequence of interleaved elements from all of the source sequences</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Interleave``1(System.Collections.Generic.IEnumerable{``0},MoreLinq.MoreEnumerable.ImbalancedInterleaveStrategy,System.Collections.Generic.IEnumerable{``0}[])">
            <summary>
            Interleaves the elements of two or more sequences into a single sequence, applying the specified strategy when sequences are of unequal length
            </summary>
            <remarks>
            Interleave combines sequences by visiting each in turn, and returning the first element of each, followed
            by the second, then the third, and so on. So, for example:<br/>
            <code><![CDATA[
            {1,1,1}.Interleave( {2,2,2}, {3,3,3} ) => { 1,2,3,1,2,3,1,2,3 }
            ]]></code>
            This operator behaves in a deferred and streaming manner.<br/>
            When sequences are of unequal length, this method will use the imbalance strategy specified to
            decide how to continue interleaving the remaining sequences. See <see cref="T:MoreLinq.MoreEnumerable.ImbalancedInterleaveStrategy"/>
            for more information.<br/>
            The sequences are interleaved in the order that they appear in the <paramref name="otherSequences"/>
            collection, with <paramref name="sequence"/> as the first sequence.
            </remarks>
            <typeparam name="T">The type of the elements of the source sequences</typeparam>
            <param name="sequence">The first sequence in the interleave group</param>
            <param name="imbalanceStrategy">Defines the behavior of the operator when sequences are of unequal length</param>
            <param name="otherSequences">The other sequences in the interleave group</param>
            <returns>A sequence of interleaved elements from all of the source sequences</returns>
        </member>
        <member name="T:MoreLinq.MoreEnumerable.ImbalancedInterleaveStrategy">
            <summary>
            Defines the strategies available when Interleave is passed sequences of unequal length
            </summary>
        </member>
        <member name="F:MoreLinq.MoreEnumerable.ImbalancedInterleaveStrategy.Pad">
            <summary>
            Extends a sequence by padding its tail with default(T)
            </summary>
        </member>
        <member name="F:MoreLinq.MoreEnumerable.ImbalancedInterleaveStrategy.Skip">
            <summary>
            Removes the sequence from the interleave set, and continues interleaving remaining sequences.
            </summary>
        </member>
        <member name="F:MoreLinq.MoreEnumerable.ImbalancedInterleaveStrategy.Stop">
            <summary>
            Stops the interleave operation.
            </summary>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Lag``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``0,``1})">
            <summary>
            Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
            </summary>
            <remarks>
            This operator evaluates in a deferred and streaming manner.<br/>
            For elements prior to the lag offset, <c>default(T)</c> is used as the lagged value.<br/>
            </remarks>
            <typeparam name="TSource">The type of the elements of the source sequence</typeparam>
            <typeparam name="TResult">The type of the elements of the result sequence</typeparam>
            <param name="source">The sequence over which to evaluate lag</param>
            <param name="offset">The offset (expressed as a positive number) by which to lag each value of the sequence</param>
            <param name="resultSelector">A projection function which accepts the current and lagged items (in that order) and returns a result</param>
            <returns>A sequence produced by projecting each element of the sequence with its lagged pairing</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Lag``2(System.Collections.Generic.IEnumerable{``0},System.Int32,``0,System.Func{``0,``0,``1})">
            <summary>
            Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset.
            </summary>
            <remarks>
            This operator evaluates in a deferred and streaming manner.<br/>
            </remarks>
            <typeparam name="TSource">The type of the elements of the source sequence</typeparam>
            <typeparam name="TResult">The type of the elements of the result sequence</typeparam>
            <param name="source">The sequence over which to evaluate lag</param>
            <param name="offset">The offset (expressed as a positive number) by which to lag each value of the sequence</param>
            <param name="defaultLagValue">A default value supplied for the lagged value prior to the lag offset</param>
            <param name="resultSelector">A projection function which accepts the current and lagged items (in that order) and returns a result</param>
            <returns>A sequence produced by projecting each element of the sequence with its lagged pairing</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Lead``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``0,``1})">
            <summary>
            Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
            </summary>
            <remarks>
            This operator evaluates in a deferred and streaming manner.<br/>
            For elements of the sequence that are less than <paramref name="offset"/> items from the end,
            default(T) is used as the lead value.<br/>
            </remarks>
            <typeparam name="TSource">The type of the elements in the source sequence</typeparam>
            <typeparam name="TResult">The type of the elements in the result sequence</typeparam>
            <param name="source">The sequence over which to evaluate Lead</param>
            <param name="offset">The offset (expressed as a positive number) by which to lead each element of the sequence</param>
            <param name="resultSelector">A projection function which accepts the current and subsequent (lead) element (in that order) and produces a result</param>
            <returns>A sequence produced by projecting each element of the sequence with its lead pairing</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Lead``2(System.Collections.Generic.IEnumerable{``0},System.Int32,``0,System.Func{``0,``0,``1})">
            <summary>
            Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset.
            </summary>
            <remarks>
            This operator evaluates in a deferred and streaming manner.<br/>
            </remarks>
            <typeparam name="TSource">The type of the elements in the source sequence</typeparam>
            <typeparam name="TResult">The type of the elements in the result sequence</typeparam>
            <param name="source">The sequence over which to evaluate Lead</param>
            <param name="offset">The offset (expressed as a positive number) by which to lead each element of the sequence</param>
            <param name="defaultLeadValue">A default value supplied for the leading element when none is available</param>
            <param name="resultSelector">A projection function which accepts the current and subsequent (lead) element (in that order) and produces a result</param>
            <returns>A sequence produced by projecting each element of the sequence with its lead pairing</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.LeftJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``0,``2})">
            <summary>
            Performs a left outer join on two homogeneous sequences.
            Additional arguments specify key selection functions and result
            projection functions.
            </summary>
            <typeparam name="TSource">
            The type of elements in the source sequence.</typeparam>
            <typeparam name="TKey">
            The type of the key returned by the key selector function.</typeparam>
            <typeparam name="TResult">
            The type of the result elements.</typeparam>
            <param name="first">
            The first sequence of the join operation.</param>
            <param name="second">
            The second sequence of the join operation.</param>
            <param name="keySelector">
            Function that projects the key given an element of one of the
            sequences to join.</param>
            <param name="firstSelector">
            Function that projects the result given just an element from
            <paramref name="first"/> where there is no corresponding element
            in <paramref name="second"/>.</param>
            <param name="bothSelector">
            Function that projects the result given an element from
            <paramref name="first"/> and an element from <paramref name="second"/>
            that match on a common key.</param>
            <returns>A sequence containing results projected from a left
            outer join of the two input sequences.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.LeftJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Performs a left outer join on two homogeneous sequences.
            Additional arguments specify key selection functions, result
            projection functions and a key comparer.
            </summary>
            <typeparam name="TSource">
            The type of elements in the source sequence.</typeparam>
            <typeparam name="TKey">
            The type of the key returned by the key selector function.</typeparam>
            <typeparam name="TResult">
            The type of the result elements.</typeparam>
            <param name="first">
            The first sequence of the join operation.</param>
            <param name="second">
            The second sequence of the join operation.</param>
            <param name="keySelector">
            Function that projects the key given an element of one of the
            sequences to join.</param>
            <param name="firstSelector">
            Function that projects the result given just an element from
            <paramref name="first"/> where there is no corresponding element
            in <paramref name="second"/>.</param>
            <param name="bothSelector">
            Function that projects the result given an element from
            <paramref name="first"/> and an element from <paramref name="second"/>
            that match on a common key.</param>
            <param name="comparer">
            The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
            keys for equality.</param>
            <returns>A sequence containing results projected from a left
            outer join of the two input sequences.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.LeftJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``0,``1,``3})">
            <summary>
            Performs a left outer join on two heterogeneous sequences.
            Additional arguments specify key selection functions and result
            projection functions.
            </summary>
            <typeparam name="TFirst">
            The type of elements in the first sequence.</typeparam>
            <typeparam name="TSecond">
            The type of elements in the second sequence.</typeparam>
            <typeparam name="TKey">
            The type of the key returned by the key selector functions.</typeparam>
            <typeparam name="TResult">
            The type of the result elements.</typeparam>
            <param name="first">
            The first sequence of the join operation.</param>
            <param name="second">
            The second sequence of the join operation.</param>
            <param name="firstKeySelector">
            Function that projects the key given an element from <paramref name="first"/>.</param>
            <param name="secondKeySelector">
            Function that projects the key given an element from <paramref name="second"/>.</param>
            <param name="firstSelector">
            Function that projects the result given just an element from
            <paramref name="first"/> where there is no corresponding element
            in <paramref name="second"/>.</param>
            <param name="bothSelector">
            Function that projects the result given an element from
            <paramref name="first"/> and an element from <paramref name="second"/>
            that match on a common key.</param>
            <returns>A sequence containing results projected from a left
            outer join of the two input sequences.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.LeftJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``0,``1,``3},System.Collections.Generic.IEqualityComparer{``2})">
            <summary>
            Performs a left outer join on two heterogeneous sequences.
            Additional arguments specify key selection functions, result
            projection functions and a key comparer.
            </summary>
            <typeparam name="TFirst">
            The type of elements in the first sequence.</typeparam>
            <typeparam name="TSecond">
            The type of elements in the second sequence.</typeparam>
            <typeparam name="TKey">
            The type of the key returned by the key selector functions.</typeparam>
            <typeparam name="TResult">
            The type of the result elements.</typeparam>
            <param name="first">
            The first sequence of the join operation.</param>
            <param name="second">
            The second sequence of the join operation.</param>
            <param name="firstKeySelector">
            Function that projects the key given an element from <paramref name="first"/>.</param>
            <param name="secondKeySelector">
            Function that projects the key given an element from <paramref name="second"/>.</param>
            <param name="firstSelector">
            Function that projects the result given just an element from
            <paramref name="first"/> where there is no corresponding element
            in <paramref name="second"/>.</param>
            <param name="bothSelector">
            Function that projects the result given an element from
            <paramref name="first"/> and an element from <paramref name="second"/>
            that match on a common key.</param>
            <param name="comparer">
            The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
            keys for equality.</param>
            <returns>A sequence containing results projected from a left
            outer join of the two input sequences.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.First``1(MoreLinq.IExtremaEnumerable{``0})">
            <summary>
            Returns the first element of a sequence.
            </summary>
            <typeparam name="T">
            The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The input sequence.</param>
            <exception cref="T:System.InvalidOperationException">
            The input sequence is empty.</exception>
            <returns>
            The first element of the input sequence.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.FirstOrDefault``1(MoreLinq.IExtremaEnumerable{``0})">
            <summary>
            Returns the first element of a sequence, or a default value if the
            sequence contains no elements.
            </summary>
            <typeparam name="T">
            The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The input sequence.</param>
            <returns>
            Default value of type <typeparamref name="T"/> if source is empty;
            otherwise, the first element in source.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Last``1(MoreLinq.IExtremaEnumerable{``0})">
            <summary>
            Returns the last element of a sequence.
            </summary>
            <typeparam name="T">
            The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The input sequence.</param>
            <exception cref="T:System.InvalidOperationException">
            The input sequence is empty.</exception>
            <returns>
            The last element of the input sequence.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.LastOrDefault``1(MoreLinq.IExtremaEnumerable{``0})">
            <summary>
            Returns the last element of a sequence, or a default value if the
            sequence contains no elements.
            </summary>
            <typeparam name="T">
            The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The input sequence.</param>
            <returns>
            Default value of type <typeparamref name="T"/> if source is empty;
            otherwise, the last element in source.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Single``1(MoreLinq.IExtremaEnumerable{``0})">
            <summary>
            Returns the only element of a sequence, and throws an exception if
            there is not exactly one element in the sequence.
            </summary>
            <typeparam name="T">
            The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The input sequence.</param>
            <exception cref="T:System.InvalidOperationException">
            The input sequence contains more than one element.</exception>
            <returns>
            The single element of the input sequence.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.SingleOrDefault``1(MoreLinq.IExtremaEnumerable{``0})">
            <summary>
            Returns the only element of a sequence, or a default value if the
            sequence is empty; this method throws an exception if there is more
            than one element in the sequence.
            </summary>
            <typeparam name="T">
            The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The input sequence.</param>
            <returns>
            The single element of the input sequence, or default value of type
            <typeparamref name="T"/> if the sequence contains no elements.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Returns the maximal elements of the given sequence, based on
            the given projection.
            </summary>
            <remarks>
            This overload uses the default comparer for the projected type.
            This operator uses deferred execution. The results are evaluated
            and cached on first use to returned sequence.
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="selector">Selector to use to pick the results to compare</param>
            <returns>The maximal element, according to the projection.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> is empty</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
            <summary>
            Returns the maximal elements of the given sequence, based on
            the given projection and the specified comparer for projected values.
            </summary>
            <remarks>
            This operator uses deferred execution. The results are evaluated
            and cached on first use to returned sequence.
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="selector">Selector to use to pick the results to compare</param>
            <param name="comparer">Comparer to use to compare projected values</param>
            <returns>The maximal element, according to the projection.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/>, <paramref name="selector"/>
            or <paramref name="comparer"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> is empty</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Returns the minimal elements of the given sequence, based on
            the given projection.
            </summary>
            <remarks>
            This overload uses the default comparer for the projected type.
            This operator uses deferred execution. The results are evaluated
            and cached on first use to returned sequence.
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="selector">Selector to use to pick the results to compare</param>
            <returns>The minimal element, according to the projection.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="selector"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> is empty</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
            <summary>
            Returns the minimal elements of the given sequence, based on
            the given projection and the specified comparer for projected values.
            </summary>
            <remarks>
            This operator uses deferred execution. The results are evaluated
            and cached on first use to returned sequence.
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="selector">Selector to use to pick the results to compare</param>
            <param name="comparer">Comparer to use to compare projected values</param>
            <returns>The minimal element, according to the projection.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/>, <paramref name="selector"/>
            or <paramref name="comparer"/> is null</exception>
            <exception cref="T:System.InvalidOperationException"><paramref name="source"/> is empty</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Move``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Int32,System.Int32)">
            <summary>
            Returns a sequence with a range of elements in the source sequence
            moved to a new offset.
            </summary>
            <typeparam name="T">Type of the source sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="fromIndex">
            The zero-based index identifying the first element in the range of
            elements to move.</param>
            <param name="count">The count of items to move.</param>
            <param name="toIndex">
            The index where the specified range will be moved.</param>
            <returns>
            A sequence with the specified range moved to the new position.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code><![CDATA[
            var result = Enumerable.Range(0, 6).Move(3, 2, 0);
            ]]></code>
            The <c>result</c> variable will contain <c>{ 3, 4, 0, 1, 2, 5 }</c>.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.NestedLoops(System.Action,System.Collections.Generic.IEnumerable{System.Int32})">
            <summary>
            Produces a sequence from an action based on the dynamic generation of N nested loops
            whose iteration counts are defined by a sequence of loop counts.
            </summary>
            <param name="action">Action delegate for which to produce a nested loop sequence</param>
            <param name="loopCounts">A sequence of loop repetition counts</param>
            <returns>A sequence of Action representing the expansion of a set of nested loops</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},MoreLinq.OrderByDirection)">
            <summary>
            Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
            </summary>
            <typeparam name="T">The type of the elements in the source sequence</typeparam>
            <typeparam name="TKey">The type of the key used to order elements</typeparam>
            <param name="source">The sequence to order</param>
            <param name="keySelector">A key selector function</param>
            <param name="direction">A direction in which to order the elements (ascending, descending)</param>
            <returns>An ordered copy of the source sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)">
            <summary>
            Sorts the elements of a sequence in a particular direction (ascending, descending) according to a key
            </summary>
            <typeparam name="T">The type of the elements in the source sequence</typeparam>
            <typeparam name="TKey">The type of the key used to order elements</typeparam>
            <param name="source">The sequence to order</param>
            <param name="keySelector">A key selector function</param>
            <param name="direction">A direction in which to order the elements (ascending, descending)</param>
            <param name="comparer">A comparer used to define the semantics of element comparison</param>
            <returns>An ordered copy of the source sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ThenBy``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1},MoreLinq.OrderByDirection)">
            <summary>
            Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
            </summary>
            <typeparam name="T">The type of the elements in the source sequence</typeparam>
            <typeparam name="TKey">The type of the key used to order elements</typeparam>
            <param name="source">The sequence to order</param>
            <param name="keySelector">A key selector function</param>
            <param name="direction">A direction in which to order the elements (ascending, descending)</param>
            <returns>An ordered copy of the source sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ThenBy``2(System.Linq.IOrderedEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)">
            <summary>
            Performs a subsequent ordering of elements in a sequence in a particular direction (ascending, descending) according to a key
            </summary>
            <typeparam name="T">The type of the elements in the source sequence</typeparam>
            <typeparam name="TKey">The type of the key used to order elements</typeparam>
            <param name="source">The sequence to order</param>
            <param name="keySelector">A key selector function</param>
            <param name="direction">A direction in which to order the elements (ascending, descending)</param>
            <param name="comparer">A comparer used to define the semantics of element comparison</param>
            <returns>An ordered copy of the source sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.OrderedMerge``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Merges two ordered sequences into one. Where the elements equal
            in both sequences, the element from the first sequence is
            returned in the resulting sequence.
            </summary>
            <typeparam name="T">Type of elements in input and output sequences.</typeparam>
            <param name="first">The first input sequence.</param>
            <param name="second">The second input sequence.</param>
            <returns>
            A sequence with elements from the two input sequences merged, as
            in a full outer join.</returns>
            <remarks>
            This method uses deferred execution. The behavior is undefined
            if the sequences are unordered as inputs.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.OrderedMerge``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Merges two ordered sequences into one with an additional
            parameter specifying how to compare the elements of the
            sequences. Where the elements equal in both sequences, the
            element from the first sequence is returned in the resulting
            sequence.
            </summary>
            <typeparam name="T">Type of elements in input and output sequences.</typeparam>
            <param name="first">The first input sequence.</param>
            <param name="second">The second input sequence.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
            <returns>
            A sequence with elements from the two input sequences merged, as
            in a full outer join.</returns>
            <remarks>
            This method uses deferred execution. The behavior is undefined
            if the sequences are unordered as inputs.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.OrderedMerge``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Merges two ordered sequences into one with an additional
            parameter specifying the element key by which the sequences are
            ordered. Where the keys equal in both sequences, the
            element from the first sequence is returned in the resulting
            sequence.
            </summary>
            <typeparam name="T">Type of elements in input and output sequences.</typeparam>
            <typeparam name="TKey">Type of keys used for merging.</typeparam>
            <param name="first">The first input sequence.</param>
            <param name="second">The second input sequence.</param>
            <param name="keySelector">Function to extract a key given an element.</param>
            <returns>
            A sequence with elements from the two input sequences merged
            according to a key, as in a full outer join.</returns>
            <remarks>
            This method uses deferred execution. The behavior is undefined
            if the sequences are unordered (by key) as inputs.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.OrderedMerge``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``2},System.Func{``0,``0,``2})">
            <summary>
            Merges two ordered sequences into one. Additional parameters
            specify the element key by which the sequences are ordered,
            the result when element is found in first sequence but not in
            the second, the result when element is found in second sequence
            but not in the first and the result when elements are found in
            both sequences.
            </summary>
            <typeparam name="T">Type of elements in source sequences.</typeparam>
            <typeparam name="TKey">Type of keys used for merging.</typeparam>
            <typeparam name="TResult">Type of elements in the returned sequence.</typeparam>
            <param name="first">The first input sequence.</param>
            <param name="second">The second input sequence.</param>
            <param name="keySelector">Function to extract a key given an element.</param>
            <param name="firstSelector">Function to project the result element
            when only the first sequence yields a source element.</param>
            <param name="secondSelector">Function to project the result element
            when only the second sequence yields a source element.</param>
            <param name="bothSelector">Function to project the result element
            when only both sequences yield a source element whose keys are
            equal.</param>
            <returns>
            A sequence with projections from the two input sequences merged
            according to a key, as in a full outer join.</returns>
            <remarks>
            This method uses deferred execution. The behavior is undefined
            if the sequences are unordered (by key) as inputs.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.OrderedMerge``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``2},System.Func{``0,``0,``2},System.Collections.Generic.IComparer{``1})">
            <summary>
            Merges two ordered sequences into one. Additional parameters
            specify the element key by which the sequences are ordered,
            the result when element is found in first sequence but not in
            the second, the result when element is found in second sequence
            but not in the first, the result when elements are found in
            both sequences and a method for comparing keys.
            </summary>
            <typeparam name="T">Type of elements in source sequences.</typeparam>
            <typeparam name="TKey">Type of keys used for merging.</typeparam>
            <typeparam name="TResult">Type of elements in the returned sequence.</typeparam>
            <param name="first">The first input sequence.</param>
            <param name="second">The second input sequence.</param>
            <param name="keySelector">Function to extract a key given an element.</param>
            <param name="firstSelector">Function to project the result element
            when only the first sequence yields a source element.</param>
            <param name="secondSelector">Function to project the result element
            when only the second sequence yields a source element.</param>
            <param name="bothSelector">Function to project the result element
            when only both sequences yield a source element whose keys are
            equal.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> to compare keys.</param>
            <returns>
            A sequence with projections from the two input sequences merged
            according to a key, as in a full outer join.</returns>
            <remarks>
            This method uses deferred execution. The behavior is undefined
            if the sequences are unordered (by key) as inputs.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.OrderedMerge``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``1,``3},System.Func{``0,``1,``3})">
            <summary>
            Merges two heterogeneous sequences ordered by a common key type
            into a homogeneous one. Additional parameters specify the
            element key by which the sequences are ordered, the result when
            element is found in first sequence but not in the second and
            the result when element is found in second sequence but not in
            the first, the result when elements are found in both sequences.
            </summary>
            <typeparam name="TFirst">Type of elements in the first sequence.</typeparam>
            <typeparam name="TSecond">Type of elements in the second sequence.</typeparam>
            <typeparam name="TKey">Type of keys used for merging.</typeparam>
            <typeparam name="TResult">Type of elements in the returned sequence.</typeparam>
            <param name="first">The first input sequence.</param>
            <param name="second">The second input sequence.</param>
            <param name="firstKeySelector">Function to extract a key given an
            element from the first sequence.</param>
            <param name="secondKeySelector">Function to extract a key given an
            element from the second sequence.</param>
            <param name="firstSelector">Function to project the result element
            when only the first sequence yields a source element.</param>
            <param name="secondSelector">Function to project the result element
            when only the second sequence yields a source element.</param>
            <param name="bothSelector">Function to project the result element
            when only both sequences yield a source element whose keys are
            equal.</param>
            <returns>
            A sequence with projections from the two input sequences merged
            according to a key, as in a full outer join.</returns>
            <remarks>
            This method uses deferred execution. The behavior is undefined
            if the sequences are unordered (by key) as inputs.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.OrderedMerge``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``0,``3},System.Func{``1,``3},System.Func{``0,``1,``3},System.Collections.Generic.IComparer{``2})">
            <summary>
            Merges two heterogeneous sequences ordered by a common key type
            into a homogeneous one. Additional parameters specify the
            element key by which the sequences are ordered, the result when
            element is found in first sequence but not in the second,
            the result when element is found in second sequence but not in
            the first, the result when elements are found in both sequences
            and a method for comparing keys.
            </summary>
            <typeparam name="TFirst">Type of elements in the first sequence.</typeparam>
            <typeparam name="TSecond">Type of elements in the second sequence.</typeparam>
            <typeparam name="TKey">Type of keys used for merging.</typeparam>
            <typeparam name="TResult">Type of elements in the returned sequence.</typeparam>
            <param name="first">The first input sequence.</param>
            <param name="second">The second input sequence.</param>
            <param name="firstKeySelector">Function to extract a key given an
            element from the first sequence.</param>
            <param name="secondKeySelector">Function to extract a key given an
            element from the second sequence.</param>
            <param name="firstSelector">Function to project the result element
            when only the first sequence yields a source element.</param>
            <param name="secondSelector">Function to project the result element
            when only the second sequence yields a source element.</param>
            <param name="bothSelector">Function to project the result element
            when only both sequences yield a source element whose keys are
            equal.</param>
            <param name="comparer">An <see cref="T:System.Collections.Generic.IComparer`1"/> to compare keys.</param>
            <returns>
            A sequence with projections from the two input sequences merged
            according to a key, as in a full outer join.</returns>
            <remarks>
            This method uses deferred execution. The behavior is undefined
            if the sequences are unordered (by key) as inputs.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Pad``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Pads a sequence with default values if it is narrower (shorter
            in length) than a given width.
            </summary>
            <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>
            <returns>
            Returns a sequence that is at least as wide/long as the width/length
            specified by the <paramref name="width"/> parameter.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code><![CDATA[
            int[] numbers = { 123, 456, 789 };
            var result = numbers.Pad(5);
            ]]></code>
            The <c>result</c> variable, when iterated over, will yield
            123, 456, 789 and two zeroes, in turn.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Pad``1(System.Collections.Generic.IEnumerable{``0},System.Int32,``0)">
            <summary>
            Pads a sequence with a given filler value if it is narrower (shorter
            in length) than a given width.
            </summary>
            <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="padding">The value to use for padding.</param>
            <returns>
            Returns a sequence that is at least as wide/long as the width/length
            specified by the <paramref name="width"/> parameter.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code><![CDATA[
            int[] numbers = { 123, 456, 789 };
            var result = numbers.Pad(5, -1);
            ]]></code>
            The <c>result</c> variable, when iterated over, will yield
            123, 456, and 789 followed by two occurrences of -1, in turn.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Pad``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Int32,``0})">
            <summary>
            Pads a sequence with a dynamic filler value if it is narrower (shorter
            in length) than a given width.
            </summary>
            <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>
            <returns>
            Returns a sequence that is at least as wide/long as the width/length
            specified by the <paramref name="width"/> parameter.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code><![CDATA[
            int[] numbers = { 0, 1, 2 };
            var result = numbers.Pad(5, i => -i);
            ]]></code>
            The <c>result</c> variable, when iterated over, will yield
            0, 1, 2, -3 and -4, in turn.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PadStart``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Pads a sequence with default values in the beginning if it is narrower (shorter
            in length) than a given width.
            </summary>
            <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>
            <returns>
            Returns a sequence that is at least as wide/long as the width/length
            specified by the <paramref name="width"/> parameter.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code><![CDATA[
            int[] numbers = { 123, 456, 789 };
            var result = numbers.PadStart(5);
            ]]></code>
            The <c>result</c> variable will contain <c>{ 0, 0, 123, 456, 789 }</c>.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PadStart``1(System.Collections.Generic.IEnumerable{``0},System.Int32,``0)">
            <summary>
            Pads a sequence with a given filler value in the beginning if it is narrower (shorter
            in length) than a given width.
            An additional parameter specifies the value to use for padding.
            </summary>
            <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="padding">The value to use for padding.</param>
            <returns>
            Returns a sequence that is at least as wide/long as the width/length
            specified by the <paramref name="width"/> parameter.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code><![CDATA[
            int[] numbers = { 123, 456, 789 };
            var result = numbers.PadStart(5, -1);
            ]]></code>
            The <c>result</c> variable will contain <c>{ -1, -1, 123, 456, 789 }</c>.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PadStart``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Int32,``0})">
            <summary>
            Pads a sequence with a dynamic filler value in the beginning if it is narrower (shorter
            in length) than a given width.
            An additional parameter specifies the function to calculate padding.
            </summary>
            <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 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.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code><![CDATA[
            int[] numbers = { 123, 456, 789 };
            var result = numbers.PadStart(6, i => -i);
            ]]></code>
            The <c>result</c> variable will contain <c>{ 0, -1, -2, 123, 456, 789 }</c>.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Pairwise``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``1})">
            <summary>
            Returns a sequence resulting from applying a function to each
            element in the source sequence and its
            predecessor, with the exception of the first element which is
            only returned as the predecessor of the second element.
            </summary>
            <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
            <typeparam name="TResult">The type of the element of the returned sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="resultSelector">A transform function to apply to
            each pair of sequence.</param>
            <returns>
            Returns the resulting sequence.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code><![CDATA[
            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
            "ab", "bc" and "cd", in turn.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Combines <see cref="M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})"/>,
            where each element is its key, and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/>
            in a single operation.
            </summary>
            <typeparam name="T">Type of elements in the sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="count">Number of (maximum) elements to return.</param>
            <returns>A sequence containing at most top <paramref name="count"/>
            elements from source, in their ascending order.</returns>
            <remarks>
            This operator uses deferred execution and streams it results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32,MoreLinq.OrderByDirection)">
            <summary>
            Combines <see cref="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)"/>,
            where each element is its key, and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/>
            in a single operation.
            An additional parameter specifies the direction of the sort
            </summary>
            <typeparam name="T">Type of elements in the sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="count">Number of (maximum) elements to return.</param>
            <param name="direction">The direction in which to sort the elements</param>
            <returns>A sequence containing at most top <paramref name="count"/>
            elements from source, in the specified order.</returns>
            <remarks>
            This operator uses deferred execution and streams it results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Collections.Generic.IComparer{``0})">
            <summary>
            Combines <see cref="M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})"/>,
            where each element is its key, and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/>
            in a single operation. An additional parameter specifies how the
            elements compare to each other.
            </summary>
            <typeparam name="T">Type of elements in the sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="count">Number of (maximum) elements to return.</param>
            <param name="comparer">A <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
            <returns>A sequence containing at most top <paramref name="count"/>
            elements from source, in their ascending order.</returns>
            <remarks>
            This operator uses deferred execution and streams it results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PartialSort``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Collections.Generic.IComparer{``0},MoreLinq.OrderByDirection)">
            <summary>
            Combines <see cref="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)"/>,
            where each element is its key, and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/>
            in a single operation.
            Additional parameters specify how the elements compare to each other and
            the direction of the sort.
            </summary>
            <typeparam name="T">Type of elements in the sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="count">Number of (maximum) elements to return.</param>
            <param name="comparer">A <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
            <param name="direction">The direction in which to sort the elements</param>
            <returns>A sequence containing at most top <paramref name="count"/>
            elements from source, in the specified order.</returns>
            <remarks>
            This operator uses deferred execution and streams it results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PartialSortBy``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``1})">
            <summary>
            Combines <see cref="M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})"/>,
            and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/> in a single operation.
            </summary>
            <typeparam name="TSource">Type of elements in the sequence.</typeparam>
            <typeparam name="TKey">Type of keys.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="keySelector">A function to extract a key from an element.</param>
            <param name="count">Number of (maximum) elements to return.</param>
            <returns>A sequence containing at most top <paramref name="count"/>
            elements from source, in ascending order of their keys.</returns>
            <remarks>
            This operator uses deferred execution and streams it results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PartialSortBy``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``1},MoreLinq.OrderByDirection)">
            <summary>
            Combines <see cref="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},MoreLinq.OrderByDirection)"/>,
            and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/> in a single operation.
            An additional parameter specifies the direction of the sort
            </summary>
            <typeparam name="TSource">Type of elements in the sequence.</typeparam>
            <typeparam name="TKey">Type of keys.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="keySelector">A function to extract a key from an element.</param>
            <param name="count">Number of (maximum) elements to return.</param>
            <param name="direction">The direction in which to sort the elements</param>
            <returns>A sequence containing at most top <paramref name="count"/>
            elements from source, in the specified order of their keys.</returns>
            <remarks>
            This operator uses deferred execution and streams it results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PartialSortBy``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
            <summary>
            Combines <see cref="M:System.Linq.Enumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})"/>,
            and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/> in a single operation.
            An additional parameter specifies how the keys compare to each other.
            </summary>
            <typeparam name="TSource">Type of elements in the sequence.</typeparam>
            <typeparam name="TKey">Type of keys.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="keySelector">A function to extract a key from an element.</param>
            <param name="count">Number of (maximum) elements to return.</param>
            <param name="comparer">A <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
            <returns>A sequence containing at most top <paramref name="count"/>
            elements from source, in ascending order of their keys.</returns>
            <remarks>
            This operator uses deferred execution and streams it results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PartialSortBy``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,``1},System.Collections.Generic.IComparer{``1},MoreLinq.OrderByDirection)">
            <summary>
            Combines <see cref="M:MoreLinq.MoreEnumerable.OrderBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},MoreLinq.OrderByDirection)"/>,
            and <see cref="M:System.Linq.Enumerable.Take``1(System.Collections.Generic.IEnumerable{``0},System.Int32)"/> in a single operation.
            Additional parameters specify how the elements compare to each other and
            the direction of the sort.
            </summary>
            <typeparam name="TSource">Type of elements in the sequence.</typeparam>
            <typeparam name="TKey">Type of keys.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="keySelector">A function to extract a key from an element.</param>
            <param name="count">Number of (maximum) elements to return.</param>
            <param name="comparer">A <see cref="T:System.Collections.Generic.IComparer`1"/> to compare elements.</param>
            <param name="direction">The direction in which to sort the elements</param>
            <returns>A sequence containing at most top <paramref name="count"/>
            elements from source, in the specified order of their keys.</returns>
            <remarks>
            This operator uses deferred execution and streams it results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Partition``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
            <summary>
            Partitions or splits a sequence in two using a predicate.
            </summary>
            <param name="source">The source sequence.</param>
            <param name="predicate">The predicate function.</param>
            <typeparam name="T">Type of source elements.</typeparam>
            <returns>
            A tuple of elements staisfying the predicate and those that do not,
            respectively.
            </returns>
            <example>
            <code><![CDATA[
            var (evens, odds) =
                Enumerable.Range(0, 10).Partition(x => x % 2 == 0);
            ]]></code>
            The <c>evens</c> variable, when iterated over, will yield 0, 2, 4, 6
            and then 8. The <c>odds</c> variable, when iterated over, will yield
            1, 3, 5, 7 and then 9.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Partition``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},``1})">
            <summary>
            Partitions or splits a sequence in two using a predicate and then
            projects a result from the two.
            </summary>
            <param name="source">The source sequence.</param>
            <param name="predicate">The predicate function.</param>
            <param name="resultSelector">
            Function that projects the result from sequences of elements that
            satisfy the predicate and those that do not, respectively, passed as
            arguments.
            </param>
            <typeparam name="T">Type of source elements.</typeparam>
            <typeparam name="TResult">Type of the result.</typeparam>
            <returns>
            The return value from <paramref name="resultSelector"/>.
            </returns>
            <example>
            <code><![CDATA[
            var (evens, odds) =
                Enumerable.Range(0, 10)
                          .Partition(x => x % 2 == 0, ValueTuple.Create);
            ]]></code>
            The <c>evens</c> variable, when iterated over, will yield 0, 2, 4, 6
            and then 8. The <c>odds</c> variable, when iterated over, will yield
            1, 3, 5, 7 and then 9.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Partition``2(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{System.Boolean,``0}},System.Func{System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},``1})">
            <summary>
            Partitions a grouping by Boolean keys into a projection of true
            elements and false elements, respectively.
            </summary>
            <typeparam name="T">Type of elements in source groupings.</typeparam>
            <typeparam name="TResult">Type of the result.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="resultSelector">
            Function that projects the result from sequences of true elements
            and false elements, respectively, passed as arguments.
            </param>
            <returns>
            The return value from <paramref name="resultSelector"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Partition``2(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{System.Nullable{System.Boolean},``0}},System.Func{System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},``1})">
            <summary>
            Partitions a grouping by nullable Boolean keys into a projection of
            true elements, false elements and null elements, respectively.
            </summary>
            <typeparam name="T">Type of elements in source groupings.</typeparam>
            <typeparam name="TResult">Type of the result.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="resultSelector">
            Function that projects the result from sequences of true elements,
            false elements and null elements, respectively, passed as
            arguments.
            </param>
            <returns>
            The return value from <paramref name="resultSelector"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
            <summary>
            Partitions a grouping and projects a result from group elements
            matching a key and those groups that do not.
            </summary>
            <typeparam name="TKey">Type of keys in source groupings.</typeparam>
            <typeparam name="TElement">Type of elements in source groupings.</typeparam>
            <typeparam name="TResult">Type of the result.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="key">The key to partition.</param>
            <param name="resultSelector">
            Function that projects the result from sequences of elements
            matching <paramref name="key"/> and those groups that do not (in
            the order in which they appear in <paramref name="source"/>),
            passed as arguments.
            </param>
            <returns>
            The return value from <paramref name="resultSelector"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,System.Collections.Generic.IEqualityComparer{``0},System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
            <summary>
            Partitions a grouping and projects a result from group elements
            matching a key and those groups that do not. An additional parameter
            specifies how to compare keys for equality.
            </summary>
            <typeparam name="TKey">Type of keys in source groupings.</typeparam>
            <typeparam name="TElement">Type of elements in source groupings.</typeparam>
            <typeparam name="TResult">Type of the result.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="key">The key to partition on.</param>
            <param name="comparer">The comparer for keys.</param>
            <param name="resultSelector">
            Function that projects the result from elements of the group
            matching <paramref name="key"/> and those groups that do not (in
            the order in which they appear in <paramref name="source"/>),
            passed as arguments.
            </param>
            <returns>
            The return value from <paramref name="resultSelector"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,``0,System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
            <summary>
            Partitions a grouping and projects a result from elements of
            groups matching a set of two keys and those groups that do not.
            </summary>
            <typeparam name="TKey">Type of keys in source groupings.</typeparam>
            <typeparam name="TElement">Type of elements in source groupings.</typeparam>
            <typeparam name="TResult">Type of the result.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="key1">The first key to partition on.</param>
            <param name="key2">The second key to partition on.</param>
            <param name="resultSelector">
            Function that projects the result from elements of the group
            matching <paramref name="key1"/>, elements of the group matching
            <paramref name="key2"/> and those groups that do not (in the order
            in which they appear in <paramref name="source"/>), passed as
            arguments.
            </param>
            <returns>
            The return value from <paramref name="resultSelector"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,``0,System.Collections.Generic.IEqualityComparer{``0},System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
            <summary>
            Partitions a grouping and projects a result from elements of
            groups matching a set of two keys and those groups that do not.
            An additional parameter specifies how to compare keys for equality.
            </summary>
            <typeparam name="TKey">Type of keys in source groupings.</typeparam>
            <typeparam name="TElement">Type of elements in source groupings.</typeparam>
            <typeparam name="TResult">Type of the result.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="key1">The first key to partition on.</param>
            <param name="key2">The second key to partition on.</param>
            <param name="comparer">The comparer for keys.</param>
            <param name="resultSelector">
            Function that projects the result from elements of the group
            matching <paramref name="key1"/>, elements of the group matching
            <paramref name="key2"/> and those groups that do not (in the order
            in which they appear in <paramref name="source"/>), passed as
            arguments.
            </param>
            <returns>
            The return value from <paramref name="resultSelector"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,``0,``0,System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
            <summary>
            Partitions a grouping and projects a result from elements groups
            matching a set of three keys and those groups that do not.
            </summary>
            <typeparam name="TKey">Type of keys in source groupings.</typeparam>
            <typeparam name="TElement">Type of elements in source groupings.</typeparam>
            <typeparam name="TResult">Type of the result.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="key1">The first key to partition on.</param>
            <param name="key2">The second key to partition on.</param>
            <param name="key3">The third key to partition on.</param>
            <param name="resultSelector">
            Function that projects the result from elements of groups
            matching <paramref name="key1"/>, <paramref name="key2"/> and
            <paramref name="key3"/> and those groups that do not (in the order
            in which they appear in <paramref name="source"/>), passed as
            arguments.
            </param>
            <returns>
            The return value from <paramref name="resultSelector"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Partition``3(System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``0,``0,``0,System.Collections.Generic.IEqualityComparer{``0},System.Func{System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{System.Linq.IGrouping{``0,``1}},``2})">
            <summary>
            Partitions a grouping and projects a result from elements groups
            matching a set of three keys and those groups that do not. An
            additional parameter specifies how to compare keys for equality.
            </summary>
            <typeparam name="TKey">Type of keys in source groupings.</typeparam>
            <typeparam name="TElement">Type of elements in source groupings.</typeparam>
            <typeparam name="TResult">Type of the result.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="key1">The first key to partition on.</param>
            <param name="key2">The second key to partition on.</param>
            <param name="key3">The third key to partition on.</param>
            <param name="comparer">The comparer for keys.</param>
            <param name="resultSelector">
            Function that projects the result from elements of groups
            matching <paramref name="key1"/>, <paramref name="key2"/> and
            <paramref name="key3"/> and those groups that do not (in
            the order in which they appear in <paramref name="source"/>),
            passed as arguments.
            </param>
            <returns>
            The return value from <paramref name="resultSelector"/>.
            </returns>
        </member>
        <member name="T:MoreLinq.MoreEnumerable.PermutationEnumerator`1">
            <summary>
            The private implementation class that produces permutations of a sequence.
            </summary>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PermutationEnumerator`1.NextPermutation">
            <summary>
            Transposes elements in the cached permutation array to produce the next permutation
            </summary>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PermutationEnumerator`1.PermuteValueSet">
            <summary>
            Creates a new list containing the values from the original
            set in their new permuted order.
            </summary>
            <remarks>
            The reason we return a new permuted value set, rather than reuse
            an existing collection, is that we have no control over what the
            consumer will do with the results produced. They could very easily
            generate and store a set of permutations and only then begin to
            process them. If we reused the same collection, the caller would
            be surprised to discover that all of the permutations looked the
            same.
            </remarks>
            <returns>List of permuted source sequence values</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Permutations``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Generates a sequence of lists that represent the permutations of the original sequence.
            </summary>
            <remarks>
            A permutation is a unique re-ordering of the elements of the sequence.<br/>
            This operator returns permutations in a deferred, streaming fashion; however, each
            permutation is materialized into a new list. There are N! permutations of a sequence,
            where N => sequence.Count().<br/>
            Be aware that the original sequence is considered one of the permutations and will be
            returned as one of the results.
            </remarks>
            <typeparam name="T">The type of the elements in the sequence</typeparam>
            <param name="sequence">The original sequence to permute</param>
            <returns>A sequence of lists representing permutations of the original sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Pipe``1(System.Collections.Generic.IEnumerable{``0},System.Action{``0})">
            <summary>
            Executes the given action on each element in the source sequence
            and yields it.
            </summary>
            <typeparam name="T">The type of the elements in the sequence</typeparam>
            <param name="source">The sequence of elements</param>
            <param name="action">The action to execute on each element</param>
            <returns>A sequence with source elements in their original order.</returns>
            <remarks>
            The returned sequence is essentially a duplicate of
            the original, but with the extra action being executed while the
            sequence is evaluated. The action is always taken before the element
            is yielded, so any changes made by the action will be visible in the
            returned sequence. This operator uses deferred execution and streams it results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Prepends a single value to a sequence.
            </summary>
            <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The sequence to prepend to.</param>
            <param name="value">The value to prepend.</param>
            <returns>
            Returns a sequence where a value is prepended to it.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <code><![CDATA[
            int[] numbers = { 1, 2, 3 };
            var result = numbers.Prepend(0);
            ]]></code>
            The <c>result</c> variable, when iterated over, will yield
            0, 1, 2 and 3, in turn.
        </member>
        <member name="M:MoreLinq.MoreEnumerable.PreScan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0},``0)">
            <summary>
            Performs a pre-scan (exclusive prefix sum) on a sequence of elements.
            </summary>
            <remarks>
            An exclusive prefix sum returns an equal-length sequence where the
            N-th element is the sum of the first N-1 input elements (the first
            element is a special case, it is set to the identity). More
            generally, the pre-scan allows any commutative binary operation,
            not just a sum.
            The inclusive version of PreScan is <see cref="M:MoreLinq.MoreEnumerable.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})"/>.
            This operator uses deferred execution and streams its result.
            </remarks>
            <example>
            <code><![CDATA[
            int[] values = { 1, 2, 3, 4 };
            var prescan = values.PreScan((a, b) => a + b, 0);
            var scan = values.Scan((a, b) => a + b);
            var result = values.EquiZip(prescan, ValueTuple.Create);
            ]]></code>
            <c>prescan</c> will yield <c>{ 0, 1, 3, 6 }</c>, while <c>scan</c>
            and <c>result</c> will both yield <c>{ 1, 3, 6, 10 }</c>. This
            shows the relationship between the inclusive and exclusive prefix sum.
            </example>
            <typeparam name="TSource">Type of elements in source sequence</typeparam>
            <param name="source">Source sequence</param>
            <param name="transformation">Transformation operation</param>
            <param name="identity">Identity element (see remarks)</param>
            <returns>The scanned sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Random">
            <summary>
            Returns an infinite sequence of random integers using the standard
            .NET random number generator.
            </summary>
            <returns>An infinite sequence of random integers</returns>
            <remarks>
            The implementation internally uses a shared, thread-local instance of
            <see cref="T:System.Random" /> to generate a random number on each
            iteration. The actual <see cref="T:System.Random" /> instance used
            therefore will depend on the thread on which a single iteration is
            taking place; that is the call to
            <see cref="M:System.Collections.IEnumerator.MoveNext" />. If the
            overall iteration takes place on different threads (e.g.
            via asynchronous awaits completing on different threads) then various
            different <see cref="T:System.Random" /> instances will be involved
            in the generation of the sequence of random numbers. Because the
            <see cref="T:System.Random" /> instance is shared, if multiple sequences
            are generated on the same thread, the order of enumeration affects the
            resulting sequences.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Random(System.Random)">
            <summary>
            Returns an infinite sequence of random integers using the supplied
            random number generator.
            </summary>
            <param name="rand">Random generator used to produce random numbers</param>
            <returns>An infinite sequence of random integers</returns>
            <exception cref="T:System.ArgumentNullException">Thrown if <paramref name="rand"/> is <see langword="null"/>.</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Random(System.Int32)">
            <summary>
            Returns an infinite sequence of random integers between zero and
            a given maximum.
            </summary>
            <param name="maxValue">exclusive upper bound for the random values returned</param>
            <returns>An infinite sequence of random integers</returns>
            <remarks>
            The implementation internally uses a shared, thread-local instance of
            <see cref="T:System.Random" /> to generate a random number on each
            iteration. The actual <see cref="T:System.Random" /> instance used
            therefore will depend on the thread on which a single iteration is
            taking place; that is the call to
            <see cref="M:System.Collections.IEnumerator.MoveNext" />. If the
            overall iteration takes place on different threads (e.g.
            via asynchronous awaits completing on different threads) then various
            different <see cref="T:System.Random" /> instances will be involved
            in the generation of the sequence of random numbers. Because the
            <see cref="T:System.Random" /> instance is shared, if multiple sequences
            are generated on the same thread, the order of enumeration affects the
            resulting sequences.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Random(System.Random,System.Int32)">
            <summary>
            Returns an infinite sequence of random integers between zero and a
            given maximum using the supplied random number generator.
            </summary>
            <param name="rand">Random generator used to produce values</param>
            <param name="maxValue">Exclusive upper bound for random values returned</param>
            <returns>An infinite sequence of random integers</returns>
            <exception cref="T:System.ArgumentNullException">Thrown if <paramref name="rand"/> is <see langword="null"/>.</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Random(System.Int32,System.Int32)">
            <summary>
            Returns an infinite sequence of random integers between a given
            minimum and a maximum.
            </summary>
            <param name="minValue">Inclusive lower bound of the values returned</param>
            <param name="maxValue">Exclusive upper bound of the values returned</param>
            <returns>An infinite sequence of random integers</returns>
            <remarks>
            The implementation internally uses a shared, thread-local instance of
            <see cref="T:System.Random" /> to generate a random number on each
            iteration. The actual <see cref="T:System.Random" /> instance used
            therefore will depend on the thread on which a single iteration is
            taking place; that is the call to
            <see cref="M:System.Collections.IEnumerator.MoveNext" />. If the
            overall iteration takes place on different threads (e.g.
            via asynchronous awaits completing on different threads) then various
            different <see cref="T:System.Random" /> instances will be involved
            in the generation of the sequence of random numbers. Because the
            <see cref="T:System.Random" /> instance is shared, if multiple sequences
            are generated on the same thread, the order of enumeration affects the
            resulting sequences.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Random(System.Random,System.Int32,System.Int32)">
            <summary>
            Returns an infinite sequence of random integers between a given
            minumum and a maximum using the supplied random number generator.
            </summary>
            <param name="rand">Generator used to produce random numbers</param>
            <param name="minValue">Inclusive lower bound of the values returned</param>
            <param name="maxValue">Exclusive upper bound of the values returned</param>
            <returns>An infinite sequence of random integers</returns>
            <exception cref="T:System.ArgumentNullException">Thrown if <paramref name="rand"/> is <see langword="null"/>.</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.RandomDouble">
            <summary>
            Returns an infinite sequence of random double values between 0.0 and 1.0
            </summary>
            <returns>An infinite sequence of random doubles</returns>
            <remarks>
            The implementation internally uses a shared, thread-local instance of
            <see cref="T:System.Random" /> to generate a random number on each
            iteration. The actual <see cref="T:System.Random" /> instance used
            therefore will depend on the thread on which a single iteration is
            taking place; that is the call to
            <see cref="M:System.Collections.IEnumerator.MoveNext" />. If the
            overall iteration takes place on different threads (e.g.
            via asynchronous awaits completing on different threads) then various
            different <see cref="T:System.Random" /> instances will be involved
            in the generation of the sequence of random numbers. Because the
            <see cref="T:System.Random" /> instance is shared, if multiple sequences
            are generated on the same thread, the order of enumeration affects the
            resulting sequences.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.RandomDouble(System.Random)">
            <summary>
            Returns an infinite sequence of random double values between 0.0 and 1.0
            using the supplied random number generator.
            </summary>
            <param name="rand">Generator used to produce random numbers</param>
            <returns>An infinite sequence of random doubles</returns>
            <exception cref="T:System.ArgumentNullException">Thrown if <paramref name="rand"/> is <see langword="null"/>.</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.RandomImpl``1(System.Random,System.Func{System.Random,``0})">
            <summary>
            This is the underlying implementation that all random operators use to
            produce a sequence of random values.
            </summary>
            <typeparam name="T">The type of value returned (either Int32 or Double)</typeparam>
            <param name="rand">Random generators used to produce the sequence</param>
            <param name="nextValue">Generator function that actually produces the next value - specific to T</param>
            <returns>An infinite sequence of random numbers of type T</returns>
        </member>
        <member name="T:MoreLinq.MoreEnumerable.GlobalRandom">
            <remarks>
            <see cref="T:System.Random"/> is not thread-safe so the following
            implementation uses thread-local <see cref="T:System.Random"/>
            instances to create the illusion of a global
            <see cref="T:System.Random"/> implementation. For some background,
            see <a href="https://blogs.msdn.microsoft.com/pfxteam/2009/02/19/getting-random-numbers-in-a-thread-safe-way/">Getting
            random numbers in a thread-safe way</a>
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.RandomSubset``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Returns a sequence of a specified size of random elements from the
            original sequence.
            </summary>
            <typeparam name="T">The type of source sequence elements.</typeparam>
            <param name="source">
            The sequence from which to return random elements.</param>
            <param name="subsetSize">The size of the random subset to return.</param>
            <returns>
            A random sequence of elements in random order from the original
            sequence.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.RandomSubset``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Random)">
            <summary>
            Returns a sequence of a specified size of random elements from the
            original sequence. An additional parameter specifies a random
            generator to be used for the random selection algorithm.
            </summary>
            <typeparam name="T">The type of source sequence elements.</typeparam>
            <param name="source">
            The sequence from which to return random elements.</param>
            <param name="subsetSize">The size of the random subset to return.</param>
            <param name="rand">
            A random generator used as part of the selection algorithm.</param>
            <returns>
            A random sequence of elements in random order from the original
            sequence.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Rank``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Ranks each item in the sequence in descending ordering using a default comparer.
            </summary>
            <typeparam name="TSource">Type of item in the sequence</typeparam>
            <param name="source">The sequence whose items will be ranked</param>
            <returns>A sequence of position integers representing the ranks of the corresponding items in the sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Rank``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IComparer{``0})">
            <summary>
            Rank each item in the sequence using a caller-supplied comparer.
            </summary>
            <typeparam name="TSource">The type of the elements in the source sequence</typeparam>
            <param name="source">The sequence of items to rank</param>
            <param name="comparer">A object that defines comparison semantics for the elements in the sequence</param>
            <returns>A sequence of position integers representing the ranks of the corresponding items in the sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.RankBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Ranks each item in the sequence in descending ordering by a specified key using a default comparer
            </summary>
            <typeparam name="TSource">The type of the elements in the source sequence</typeparam>
            <typeparam name="TKey">The type of the key used to rank items in the sequence</typeparam>
            <param name="source">The sequence of items to rank</param>
            <param name="keySelector">A key selector function which returns the value by which to rank items in the sequence</param>
            <returns>A sequence of position integers representing the ranks of the corresponding items in the sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.RankBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1})">
            <summary>
            Ranks each item in a sequence using a specified key and a caller-supplied comparer
            </summary>
            <typeparam name="TSource">The type of the elements in the source sequence</typeparam>
            <typeparam name="TKey">The type of the key used to rank items in the sequence</typeparam>
            <param name="source">The sequence of items to rank</param>
            <param name="keySelector">A key selector function which returns the value by which to rank items in the sequence</param>
            <param name="comparer">An object that defines the comparison semantics for keys used to rank items</param>
            <returns>A sequence of position integers representing the ranks of the corresponding items in the sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Repeat``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Repeats the sequence the specified number of times.
            </summary>
            <typeparam name="T">Type of elements in sequence</typeparam>
            <param name="sequence">The sequence to repeat</param>
            <param name="count">Number of times to repeat the sequence</param>
            <returns>A sequence produced from the repetition of the original source sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Repeat``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Repeats the sequence forever.
            </summary>
            <typeparam name="T">Type of elements in sequence</typeparam>
            <param name="sequence">The sequence to repeat</param>
            <returns>A sequence produced from the infinite repetition of the original source sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.RightJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``0,``2})">
            <summary>
            Performs a right outer join on two homogeneous sequences.
            Additional arguments specify key selection functions and result
            projection functions.
            </summary>
            <typeparam name="TSource">
            The type of elements in the source sequence.</typeparam>
            <typeparam name="TKey">
            The type of the key returned by the key selector function.</typeparam>
            <typeparam name="TResult">
            The type of the result elements.</typeparam>
            <param name="first">
            The first sequence of the join operation.</param>
            <param name="second">
            The second sequence of the join operation.</param>
            <param name="keySelector">
            Function that projects the key given an element of one of the
            sequences to join.</param>
            <param name="secondSelector">
            Function that projects the result given just an element from
            <paramref name="second"/> where there is no corresponding element
            in <paramref name="first"/>.</param>
            <param name="bothSelector">
            Function that projects the result given an element from
            <paramref name="first"/> and an element from <paramref name="second"/>
            that match on a common key.</param>
            <returns>A sequence containing results projected from a right
            outer join of the two input sequences.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.RightJoin``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Func{``0,``0,``2},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Performs a right outer join on two homogeneous sequences.
            Additional arguments specify key selection functions, result
            projection functions and a key comparer.
            </summary>
            <typeparam name="TSource">
            The type of elements in the source sequence.</typeparam>
            <typeparam name="TKey">
            The type of the key returned by the key selector function.</typeparam>
            <typeparam name="TResult">
            The type of the result elements.</typeparam>
            <param name="first">
            The first sequence of the join operation.</param>
            <param name="second">
            The second sequence of the join operation.</param>
            <param name="keySelector">
            Function that projects the key given an element of one of the
            sequences to join.</param>
            <param name="secondSelector">
            Function that projects the result given just an element from
            <paramref name="second"/> where there is no corresponding element
            in <paramref name="first"/>.</param>
            <param name="bothSelector">
            Function that projects the result given an element from
            <paramref name="first"/> and an element from <paramref name="second"/>
            that match on a common key.</param>
            <param name="comparer">
            The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
            keys for equality.</param>
            <returns>A sequence containing results projected from a right
            outer join of the two input sequences.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.RightJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``1,``3},System.Func{``0,``1,``3})">
            <summary>
            Performs a right outer join on two heterogeneous sequences.
            Additional arguments specify key selection functions and result
            projection functions.
            </summary>
            <typeparam name="TFirst">
            The type of elements in the first sequence.</typeparam>
            <typeparam name="TSecond">
            The type of elements in the second sequence.</typeparam>
            <typeparam name="TKey">
            The type of the key returned by the key selector functions.</typeparam>
            <typeparam name="TResult">
            The type of the result elements.</typeparam>
            <param name="first">
            The first sequence of the join operation.</param>
            <param name="second">
            The second sequence of the join operation.</param>
            <param name="firstKeySelector">
            Function that projects the key given an element from <paramref name="first"/>.</param>
            <param name="secondKeySelector">
            Function that projects the key given an element from <paramref name="second"/>.</param>
            <param name="secondSelector">
            Function that projects the result given just an element from
            <paramref name="second"/> where there is no corresponding element
            in <paramref name="first"/>.</param>
            <param name="bothSelector">
            Function that projects the result given an element from
            <paramref name="first"/> and an element from <paramref name="second"/>
            that match on a common key.</param>
            <returns>A sequence containing results projected from a right
            outer join of the two input sequences.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.RightJoin``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``2},System.Func{``1,``2},System.Func{``1,``3},System.Func{``0,``1,``3},System.Collections.Generic.IEqualityComparer{``2})">
            <summary>
            Performs a right outer join on two heterogeneous sequences.
            Additional arguments specify key selection functions, result
            projection functions and a key comparer.
            </summary>
            <typeparam name="TFirst">
            The type of elements in the first sequence.</typeparam>
            <typeparam name="TSecond">
            The type of elements in the second sequence.</typeparam>
            <typeparam name="TKey">
            The type of the key returned by the key selector functions.</typeparam>
            <typeparam name="TResult">
            The type of the result elements.</typeparam>
            <param name="first">
            The first sequence of the join operation.</param>
            <param name="second">
            The second sequence of the join operation.</param>
            <param name="firstKeySelector">
            Function that projects the key given an element from <paramref name="first"/>.</param>
            <param name="secondKeySelector">
            Function that projects the key given an element from <paramref name="second"/>.</param>
            <param name="secondSelector">
            Function that projects the result given just an element from
            <paramref name="second"/> where there is no corresponding element
            in <paramref name="first"/>.</param>
            <param name="bothSelector">
            Function that projects the result given an element from
            <paramref name="first"/> and an element from <paramref name="second"/>
            that match on a common key.</param>
            <param name="comparer">
            The <see cref="T:System.Collections.Generic.IEqualityComparer`1"/> instance used to compare
            keys for equality.</param>
            <returns>A sequence containing results projected from a right
            outer join of the two input sequences.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.RunLengthEncode``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Run-length encodes a sequence by converting consecutive instances of the same element into
            a <c>KeyValuePair{T,int}</c> representing the item and its occurrence count.
            </summary>
            <typeparam name="T">The type of the elements in the sequence</typeparam>
            <param name="sequence">The sequence to run length encode</param>
            <returns>A sequence of <c>KeyValuePair{T,int}</c> where the key is the element and the value is the occurrence count</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.RunLengthEncode``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Run-length encodes a sequence by converting consecutive instances of the same element into
            a <c>KeyValuePair{T,int}</c> representing the item and its occurrence count. This overload
            uses a custom equality comparer to identify equivalent items.
            </summary>
            <typeparam name="T">The type of the elements in the sequence</typeparam>
            <param name="sequence">The sequence to run length encode</param>
            <param name="comparer">The comparer used to identify equivalent items</param>
            <returns>A sequence of <c>KeyValuePair{T,int}</c> where they key is the element and the value is the occurrence count</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
            <summary>
            Performs a scan (inclusive prefix sum) on a sequence of elements.
            </summary>
            <remarks>
            An inclusive prefix sum returns an equal-length sequence where the
            N-th element is the sum of the first N input elements. More
            generally, the scan allows any commutative binary operation, not
            just a sum.
            The exclusive version of Scan is <see cref="M:MoreLinq.MoreEnumerable.PreScan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0},``0)"/>.
            This operator uses deferred execution and streams its result.
            </remarks>
            <example>
            <code><![CDATA[
            int[] values = { 1, 2, 3, 4 };
            var prescan = values.PreScan((a, b) => a + b, 0);
            var scan = values.Scan((a, b) => a + b);
            var result = values.EquiZip(scan, ValueTuple.Create);
            ]]></code>
            <c>prescan</c> will yield <c>{ 0, 1, 3, 6 }</c>, while <c>scan</c>
            and <c>result</c> will both yield <c>{ 1, 3, 6, 10 }</c>. This
            shows the relationship between the inclusive and exclusive prefix sum.
            </example>
            <typeparam name="TSource">Type of elements in source sequence</typeparam>
            <param name="source">Source sequence</param>
            <param name="transformation">Transformation operation</param>
            <returns>The scanned sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Scan``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1})">
            <summary>
            Like <see cref="M:System.Linq.Enumerable.Aggregate``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})"/> except returns
            the sequence of intermediate results as well as the final one.
            An additional parameter specifies a seed.
            </summary>
            <remarks>
            This operator uses deferred execution and streams its result.
            </remarks>
            <example>
            <code><![CDATA[
            var result = Enumerable.Range(1, 5).Scan(0, (a, b) => a + b);
            ]]></code>
            When iterated, <c>result</c> will yield <c>{ 0, 1, 3, 6, 10, 15 }</c>.
            </example>
            <typeparam name="TSource">Type of elements in source sequence</typeparam>
            <typeparam name="TState">Type of state</typeparam>
            <param name="source">Source sequence</param>
            <param name="seed">Initial state to seed</param>
            <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.
            This operator is the right-associative version of the
            <see cref="M:MoreLinq.MoreEnumerable.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})"/> LINQ operator.
            </summary>
            <typeparam name="TSource">Type of elements in source sequence.</typeparam>
            <param name="source">Source sequence.</param>
            <param name="func">
            A right-associative accumulator function to be invoked on each element.
            Its first argument is the current value in the sequence; second argument is the previous accumulator value.
            </param>
            <returns>The scanned sequence.</returns>
            <example>
            <code><![CDATA[
            var result = Enumerable.Range(1, 5).Select(i => i.ToString()).ScanRight((a, b) => string.Format("({0}/{1})", a, b));
            ]]></code>
            The <c>result</c> variable will contain <c>[ "(1+(2+(3+(4+5))))", "(2+(3+(4+5)))", "(3+(4+5))", "(4+5)", "5" ]</c>.
            </example>
            <remarks>
            This operator uses deferred execution and streams its results.
            Source sequence is consumed greedily when an iteration of the resulting sequence begins.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ScanRight``2(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``0,``1,``1})">
            <summary>
            Peforms a right-associative scan (inclusive prefix) on a sequence of elements.
            The specified seed value is used as the initial accumulator value.
            This operator is the right-associative version of the
            <see cref="M:MoreLinq.MoreEnumerable.Scan``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>
            <param name="source">Source sequence.</param>
            <param name="seed">The initial accumulator value.</param>
            <param name="func">A right-associative accumulator function to be invoked on each element.</param>
            <returns>The scanned sequence.</returns>
            <example>
            <code><![CDATA[
            var result = Enumerable.Range(1, 4).ScanRight("5", (a, b) => string.Format("({0}/{1})", a, b));
            ]]></code>
            The <c>result</c> variable will contain <c>[ "(1+(2+(3+(4+5))))", "(2+(3+(4+5)))", "(3+(4+5))", "(4+5)", "5" ]</c>.
            </example>
            <remarks>
            This operator uses deferred execution and streams its results.
            Source sequence is consumed greedily when an iteration of the resulting sequence begins.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Segment``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
            <summary>
            Divides a sequence into multiple sequences by using a segment detector based on the original sequence
            </summary>
            <typeparam name="T">The type of the elements in the sequence</typeparam>
            <param name="source">The sequence to segment</param>
            <param name="newSegmentPredicate">A function, which returns <c>true</c> if the given element begins a new segment, and <c>false</c> otherwise</param>
            <returns>A sequence of segment, each of which is a portion of the original sequence</returns>
            <exception cref="T:System.ArgumentNullException">
            Thrown if either <paramref name="source"/> or <paramref name="newSegmentPredicate"/> are <see langword="null"/>.
            </exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Segment``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean})">
            <summary>
            Divides a sequence into multiple sequences by using a segment detector based on the original sequence
            </summary>
            <typeparam name="T">The type of the elements in the sequence</typeparam>
            <param name="source">The sequence to segment</param>
            <param name="newSegmentPredicate">A function, which returns <c>true</c> if the given element or index indicate a new segment, and <c>false</c> otherwise</param>
            <returns>A sequence of segment, each of which is a portion of the original sequence</returns>
            <exception cref="T:System.ArgumentNullException">
            Thrown if either <paramref name="source"/> or <paramref name="newSegmentPredicate"/> are <see langword="null"/>.
            </exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Segment``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,System.Int32,System.Boolean})">
            <summary>
            Divides a sequence into multiple sequences by using a segment detector based on the original sequence
            </summary>
            <typeparam name="T">The type of the elements in the sequence</typeparam>
            <param name="source">The sequence to segment</param>
            <param name="newSegmentPredicate">A function, which returns <c>true</c> if the given current element, previous element or index indicate a new segment, and <c>false</c> otherwise</param>
            <returns>A sequence of segment, each of which is a portion of the original sequence</returns>
            <exception cref="T:System.ArgumentNullException">
            Thrown if either <paramref name="source"/> or <paramref name="newSegmentPredicate"/> are <see langword="null"/>.
            </exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Sequence(System.Int32,System.Int32)">
            <summary>
            Generates a sequence of integral numbers within the (inclusive) specified range.
            If sequence is ascending the step is +1, otherwise -1.
            </summary>
            <param name="start">The value of the first integer in the sequence.</param>
            <param name="stop">The value of the last integer in the sequence.</param>
            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains a range of sequential integral numbers.</returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code><![CDATA[
            var result = MoreEnumerable.Sequence(6, 0);
            ]]></code>
            The <c>result</c> variable will contain <c>{ 6, 5, 4, 3, 2, 1, 0 }</c>.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Sequence(System.Int32,System.Int32,System.Int32)">
            <summary>
            Generates a sequence of integral numbers within the (inclusive) specified range.
            An additional parameter specifies the steps in which the integers of the sequence increase or decrease.
            </summary>
            <param name="start">The value of the first integer in the sequence.</param>
            <param name="stop">The value of the last integer in the sequence.</param>
            <param name="step">The step to define the next number.</param>
            <returns>An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains a range of sequential integral numbers.</returns>
            <remarks>
            When <paramref name="step"/> is equal to zero, this operator returns an
            infinite sequence where all elements are equals to <paramref name="start"/>.
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code><![CDATA[
            var result = MoreEnumerable.Sequence(6, 0, -2);
            ]]></code>
            The <c>result</c> variable will contain <c>{ 6, 4, 2, 0 }</c>.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Shuffle``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Returns a sequence of elements in random order from the original
            sequence.
            </summary>
            <typeparam name="T">The type of source sequence elements.</typeparam>
            <param name="source">
            The sequence from which to return random elements.</param>
            <returns>
            A sequence of elements <paramref name="source"/> randomized in
            their order.
            </returns>
            <remarks>
            This method uses deferred execution and streams its results. The
            source sequence is entirely buffered before the results are
            streamed.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Shuffle``1(System.Collections.Generic.IEnumerable{``0},System.Random)">
            <summary>
            Returns a sequence of elements in random order from the original
            sequence. An additional parameter specifies a random generator to be
            used for the random selection algorithm.
            </summary>
            <typeparam name="T">The type of source sequence elements.</typeparam>
            <param name="source">
            The sequence from which to return random elements.</param>
            <param name="rand">
            A random generator used as part of the selection algorithm.</param>
            <returns>
            A sequence of elements <paramref name="source"/> randomized in
            their order.
            </returns>
            <remarks>
            This method uses deferred execution and streams its results. The
            source sequence is entirely buffered before the results are
            streamed.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.SkipLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Bypasses a specified number of elements at the end of the sequence.
            </summary>
            <typeparam name="T">Type of the source sequence</typeparam>
            <param name="source">The source sequence.</param>
            <param name="count">The number of elements to bypass at the end of the source sequence.</param>
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> containing the source sequence elements except for the bypassed ones at the end.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.SkipUntil``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
            <summary>
            Skips items from the input sequence until the given predicate returns true
            when applied to the current source item; that item will be the last skipped.
            </summary>
            <remarks>
            <para>
            SkipUntil differs from Enumerable.SkipWhile in two respects. Firstly, the sense
            of the predicate is reversed: it is expected that the predicate will return false
            to start with, and then return true - for example, when trying to find a matching
            item in a sequence.
            </para>
            <para>
            Secondly, SkipUntil skips the element which causes the predicate to return true. For
            example, in a sequence <code><![CDATA[{ 1, 2, 3, 4, 5 }]]></code> and with a predicate of
            <code><![CDATA[x => x == 3]]></code>, the result would be <code><![CDATA[{ 4, 5 }]]></code>.
            </para>
            <para>
            SkipUntil is as lazy as possible: it will not iterate over the source sequence
            until it has to, it won't iterate further than it has to, and it won't evaluate
            the predicate until it has to. (This means that an item may be returned which would
            actually cause the predicate to throw an exception if it were evaluated, so long as
            it comes after the first item causing the predicate to return true.)
            </para>
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <param name="source">Source sequence</param>
            <param name="predicate">Predicate used to determine when to stop yielding results from the source.</param>
            <returns>Items from the source sequence after the predicate first returns true when applied to the item.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Slice``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Int32)">
            <summary>
            Extracts a contiguous count of elements from a sequence at a particular zero-based starting index
            </summary>
            <remarks>
            If the starting position or count specified result in slice extending past the end of the sequence,
            it will return all elements up to that point. There is no guarantee that the resulting sequence will
            contain the number of elements requested - it may have anywhere from 0 to <paramref name="count"/>.<br/>
            This method is implemented in an optimized manner for any sequence implementing <c>IList{T}</c>.<br/>
            The result of Slice() is identical to: <c>sequence.Skip(startIndex).Take(count)</c>
            </remarks>
            <typeparam name="T">The type of the elements in the source sequence</typeparam>
            <param name="sequence">The sequence from which to extract elements</param>
            <param name="startIndex">The zero-based index at which to begin slicing</param>
            <param name="count">The number of items to slice out of the index</param>
            <returns>A new sequence containing any elements sliced out from the source sequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.SortedMerge``1(System.Collections.Generic.IEnumerable{``0},MoreLinq.OrderByDirection,System.Collections.Generic.IEnumerable{``0}[])">
             <summary>
             Merges two or more sequences that are in a common order (either ascending or descending) into
             a single sequence that preserves that order.
             </summary>
             <remarks>
             Using SortedMerge on sequences that are not ordered or are not in the same order produces
             undefined results.<br/>
             <c>SortedMerge</c> uses performs the merge in a deferred, streaming manner. <br/>
             
             Here is an example of a merge, as well as the produced result:
             <code><![CDATA[
               var s1 = new[] { 3, 7, 11 };
               var s2 = new[] { 2, 4, 20 };
               var s3 = new[] { 17, 19, 25 };
               var merged = s1.SortedMerge( OrderByDirection.Ascending, s2, s3 );
               var result = merged.ToArray();
               // result will be:
               // { 2, 3, 4, 7, 11, 17, 19, 20, 25 }
             ]]></code>
             </remarks>
             <typeparam name="TSource">The type of the elements of the sequence</typeparam>
             <param name="source">The primary sequence with which to merge</param>
             <param name="direction">The ordering that all sequences must already exhibit</param>
             <param name="otherSequences">A variable argument array of zero or more other sequences to merge with</param>
             <returns>A merged, order-preserving sequence containing all of the elements of the original sequences</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.SortedMerge``1(System.Collections.Generic.IEnumerable{``0},MoreLinq.OrderByDirection,System.Collections.Generic.IComparer{``0},System.Collections.Generic.IEnumerable{``0}[])">
            <summary>
            Merges two or more sequences that are in a common order (either ascending or descending) into
            a single sequence that preserves that order.
            </summary>
            <typeparam name="TSource">The type of the elements in the sequence</typeparam>
            <param name="source">The primary sequence with which to merge</param>
            <param name="direction">The ordering that all sequences must already exhibit</param>
            <param name="comparer">The comparer used to evaluate the relative order between elements</param>
            <param name="otherSequences">A variable argument array of zero or more other sequences to merge with</param>
            <returns>A merged, order-preserving sequence containing al of the elements of the original sequences</returns>
        </member>
        <member name="T:MoreLinq.MoreEnumerable.DisposableGroup`1">
            <summary>
            Class used to assist in ensuring that groups of disposable iterators
            are disposed - either when Excluded or when the DisposableGroup is disposed.
            </summary>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Splits the source sequence by a separator.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="separator">Separator element.</param>
            <returns>A sequence of splits of elements.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},``0,System.Int32)">
            <summary>
            Splits the source sequence by a separator given a maximum count of splits.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="separator">Separator element.</param>
            <param name="count">Maximum number of splits.</param>
            <returns>A sequence of splits of elements.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``2(System.Collections.Generic.IEnumerable{``0},``0,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
            <summary>
            Splits the source sequence by a separator and then transforms
            the splits into results.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence.</typeparam>
            <typeparam name="TResult">Type of the result sequence elements.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="separator">Separator element.</param>
            <param name="resultSelector">Function used to project splits
            of source elements into elements of the resulting sequence.</param>
            <returns>
            A sequence of values typed as <typeparamref name="TResult"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``2(System.Collections.Generic.IEnumerable{``0},``0,System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
            <summary>
            Splits the source sequence by a separator, given a maximum count
            of splits, and then transforms the splits into results.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence.</typeparam>
            <typeparam name="TResult">Type of the result sequence elements.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="separator">Separator element.</param>
            <param name="count">Maximum number of splits.</param>
            <param name="resultSelector">Function used to project splits
            of source elements into elements of the resulting sequence.</param>
            <returns>
            A sequence of values typed as <typeparamref name="TResult"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Splits the source sequence by a separator and then transforms the
            splits into results.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="separator">Separator element.</param>
            <param name="comparer">Comparer used to determine separator
            element equality.</param>
            <returns>A sequence of splits of elements.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0},System.Int32)">
            <summary>
            Splits the source sequence by a separator, given a maximum count
            of splits. A parameter specifies how the separator is compared
            for equality.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="separator">Separator element.</param>
            <param name="comparer">Comparer used to determine separator
            element equality.</param>
            <param name="count">Maximum number of splits.</param>
            <returns>A sequence of splits of elements.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``2(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0},System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
            <summary>
            Splits the source sequence by a separator and then transforms the
            splits into results. A parameter specifies how the separator is
            compared for equality.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence.</typeparam>
            <typeparam name="TResult">Type of the result sequence elements.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="separator">Separator element.</param>
            <param name="comparer">Comparer used to determine separator
            element equality.</param>
            <param name="resultSelector">Function used to project splits
            of source elements into elements of the resulting sequence.</param>
            <returns>
            A sequence of values typed as <typeparamref name="TResult"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``2(System.Collections.Generic.IEnumerable{``0},``0,System.Collections.Generic.IEqualityComparer{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
            <summary>
            Splits the source sequence by a separator, given a maximum count
            of splits, and then transforms the splits into results. A
            parameter specifies how the separator is compared for equality.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence.</typeparam>
            <typeparam name="TResult">Type of the result sequence elements.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="separator">Separator element.</param>
            <param name="comparer">Comparer used to determine separator
            element equality.</param>
            <param name="count">Maximum number of splits.</param>
            <param name="resultSelector">Function used to project splits
            of source elements into elements of the resulting sequence.</param>
            <returns>
            A sequence of values typed as <typeparamref name="TResult"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
            <summary>
            Splits the source sequence by separator elements identified by a
            function.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="separatorFunc">Predicate function used to determine
            the splitter elements in the source sequence.</param>
            <returns>A sequence of splits of elements.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Int32)">
            <summary>
            Splits the source sequence by separator elements identified by a
            function, given a maximum count of splits.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="separatorFunc">Predicate function used to determine
            the splitter elements in the source sequence.</param>
            <param name="count">Maximum number of splits.</param>
            <returns>A sequence of splits of elements.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
            <summary>
            Splits the source sequence by separator elements identified by
            a function and then transforms the splits into results.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence.</typeparam>
            <typeparam name="TResult">Type of the result sequence elements.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="separatorFunc">Predicate function used to determine
            the splitter elements in the source sequence.</param>
            <param name="resultSelector">Function used to project splits
            of source elements into elements of the resulting sequence.</param>
            <returns>
            A sequence of values typed as <typeparamref name="TResult"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
            <summary>
            Splits the source sequence by separator elements identified by
            a function, given a maximum count of splits, and then transforms
            the splits into results.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence.</typeparam>
            <typeparam name="TResult">Type of the result sequence elements.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="separatorFunc">Predicate function used to determine
            the splitter elements in the source sequence.</param>
            <param name="count">Maximum number of splits.</param>
            <param name="resultSelector">Function used to project a split
            group of source elements into an element of the resulting sequence.</param>
            <returns>
            A sequence of values typed as <typeparamref name="TResult"/>.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.StartsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Determines whether the beginning of the first sequence is
            equivalent to the second sequence, using the default equality
            comparer.
            </summary>
            <typeparam name="T">Type of elements.</typeparam>
            <param name="first">The sequence to check.</param>
            <param name="second">The sequence to compare to.</param>
            <returns>
            <c>true</c> if <paramref name="first" /> begins with elements
            equivalent to <paramref name="second" />.
            </returns>
            <remarks>
            This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
            <see cref="M:System.String.StartsWith(System.String)" /> and it calls
            <see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> using
            <see cref="P:System.Collections.Generic.EqualityComparer`1.Default"/> on pairs of elements at
            the same index.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.StartsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Determines whether the beginning of the first sequence is
            equivalent to the second sequence, using the specified element
            equality comparer.
            </summary>
            <typeparam name="T">Type of elements.</typeparam>
            <param name="first">The sequence to check.</param>
            <param name="second">The sequence to compare to.</param>
            <param name="comparer">Equality comparer to use.</param>
            <returns>
            <c>true</c> if <paramref name="first" /> begins with elements
            equivalent to <paramref name="second" />.
            </returns>
            <remarks>
            This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
            <see cref="M:System.String.StartsWith(System.String)" /> and
            it calls <see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> on pairs
            of elements at the same index.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Subsets``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Returns a sequence of <see cref="T:System.Collections.Generic.IList`1"/> representing all of
            the subsets of any size that are part of the original sequence. In
            mathematics, it is equivalent to the <em>power set</em> of a set.
            </summary>
            <remarks>
            This operator produces all of the subsets of a given sequence. Subsets are returned
            in increasing cardinality, starting with the empty set and terminating with the
            entire original sequence.<br/>
            Subsets are produced in a deferred, streaming manner; however, each subset is returned
            as a materialized list.<br/>
            There are 2^N subsets of a given sequence, where N => sequence.Count().
            </remarks>
            <param name="sequence">Sequence for which to produce subsets</param>
            <typeparam name="T">The type of the elements in the sequence</typeparam>
            <returns>A sequence of lists that represent the all subsets of the original sequence</returns>
            <exception cref="T:System.ArgumentNullException">Thrown if <paramref name="sequence"/> is <see langword="null"/></exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Subsets``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Returns a sequence of <see cref="T:System.Collections.Generic.IList`1"/> representing all
            subsets of a given size that are part of the original sequence. In
            mathematics, it is equivalent to the <em>combinations</em> or
            <em>k-subsets</em> of a set.
            </summary>
            <param name="sequence">Sequence for which to produce subsets</param>
            <param name="subsetSize">The size of the subsets to produce</param>
            <typeparam name="T">The type of the elements in the sequence</typeparam>
            <returns>A sequence of lists that represents of K-sized subsets of the original sequence</returns>
            <exception cref="T:System.ArgumentNullException">
            Thrown if <paramref name="sequence"/> is <see langword="null"/>
            </exception>
            <exception cref="T:System.ArgumentOutOfRangeException">
            Thrown if <paramref name="subsetSize"/> is less than zero.
            </exception>
        </member>
        <member name="T:MoreLinq.MoreEnumerable.SubsetGenerator`1">
            <summary>
            This class is responsible for producing the lexographically ordered k-subsets
            </summary>
        </member>
        <member name="T:MoreLinq.MoreEnumerable.SubsetGenerator`1.SubsetEnumerator">
            <summary>
            SubsetEnumerator uses a snapshot of the original sequence, and an
            iterative, reductive swap algorithm to produce all subsets of a
            predetermined size less than or equal to the original set size.
            </summary>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.SubsetGenerator`1.GetEnumerator">
            <summary>
            Returns an enumerator that produces all of the k-sized
            subsets of the initial value set. The enumerator returns
            and <see cref="T:System.Collections.Generic.IList`1"/> for each subset.
            </summary>
            <returns>an <see cref="T:System.Collections.IEnumerator"/> that enumerates all k-sized subsets</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.TagFirstLast``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean,System.Boolean,``1})">
            <summary>
            Returns a sequence resulting from applying a function to each
            element in the source sequence with additional parameters
            indicating whether the element is the first and/or last of the
            sequence.
            </summary>
            <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
            <typeparam name="TResult">The type of the element of the returned sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="resultSelector">A function that determines how to
            project the each element along with its first or last tag.</param>
            <returns>
            Returns the resulting sequence.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code><![CDATA[
            var numbers = new[] { 123, 456, 789 };
            var result = numbers.TagFirstLast((num, fst, lst) => new
                         {
                             Number = num,
                             IsFirst = fst, IsLast = lst
                         });
            ]]></code>
            The <c>result</c> variable, when iterated over, will yield
            <c>{ Number = 123, IsFirst = True, IsLast = False }</c>,
            <c>{ Number = 456, IsFirst = False, IsLast = False }</c> and
            <c>{ Number = 789, IsFirst = False, IsLast = True }</c> in turn.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.TakeEvery``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Returns every N-th element of a sequence.
            </summary>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <param name="source">Source sequence</param>
            <param name="step">Number of elements to bypass before returning the next element.</param>
            <returns>
            A sequence with every N-th element of the input sequence.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code><![CDATA[
            int[] numbers = { 1, 2, 3, 4, 5 };
            var result = numbers.TakeEvery(2);
            ]]></code>
            The <c>result</c> variable, when iterated over, will yield 1, 3 and 5, in turn.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.TakeLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Returns a specified number of contiguous elements from the end of
            a sequence.
            </summary>
            <typeparam name="TSource">The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The sequence to return the last element of.</param>
            <param name="count">The number of elements to return.</param>
            <returns>
            An <see cref="T:System.Collections.Generic.IEnumerable`1"/> that contains the specified number of
            elements from the end of the input sequence.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code><![CDATA[
            int[] numbers = { 12, 34, 56, 78 };
            var result = numbers.TakeLast(2);
            ]]></code>
            The <c>result</c> variable, when iterated over, will yield
            56 and 78 in turn.
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.TakeUntil``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
            <summary>
            Returns items from the input sequence until the given predicate returns true
            when applied to the current source item; that item will be the last returned.
            </summary>
            <remarks>
            <para>
            TakeUntil differs from Enumerable.TakeWhile in two respects. Firstly, the sense
            of the predicate is reversed: it is expected that the predicate will return false
            to start with, and then return true - for example, when trying to find a matching
            item in a sequence.
            </para>
            <para>
            Secondly, TakeUntil yields the element which causes the predicate to return true. For
            example, in a sequence <code><![CDATA[{ 1, 2, 3, 4, 5 }]]></code> and with a predicate of
            <code><![CDATA[x => x == 3]]></code>, the result would be <code><![CDATA[{ 1, 2, 3 }]]></code>.
            </para>
            <para>
            TakeUntil is as lazy as possible: it will not iterate over the source sequence
            until it has to, it won't iterate further than it has to, and it won't evaluate
            the predicate until it has to. (This means that an item may be returned which would
            actually cause the predicate to throw an exception if it were evaluated, so long as
            no more items of data are requested.)
            </para>
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <param name="source">Source sequence</param>
            <param name="predicate">Predicate used to determine when to stop yielding results from the source.</param>
            <returns>Items from the source sequence, until the predicate returns true when applied to the item.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> or <paramref name="predicate"/> is null</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToArrayByIndex``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32})">
            <summary>
            Creates an array from an <see cref="T:System.Collections.Generic.IEnumerable`1"/> where a
            function is used to determine the index at which an element will
            be placed in the array.
            </summary>
            <param name="source">The source sequence for the array.</param>
            <param name="indexSelector">
            A function that maps an element to its index.</param>
            <typeparam name="T">
            The type of the element in <paramref name="source"/>.</typeparam>
            <returns>
            An array that contains the elements from the input sequence. The
            size of the array will be as large as the highest index returned
            by the <paramref name="indexSelector"/> plus 1.
            </returns>
            <remarks>
            This method forces immediate query evaluation. It should not be
            used on infinite sequences. If more than one element maps to the
            same index then the latter element overwrites the former in the
            resulting array.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToArrayByIndex``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32},System.Func{``0,``1})">
            <summary>
            Creates an array from an <see cref="T:System.Collections.Generic.IEnumerable`1"/> where a
            function is used to determine the index at which an element will
            be placed in the array. The elements are projected into the array
            via an additional function.
            </summary>
            <param name="source">The source sequence for the array.</param>
            <param name="indexSelector">
            A function that maps an element to its index.</param>
            <param name="resultSelector">
            A function to project a source element into an element of the
            resulting array.</param>
            <typeparam name="T">
            The type of the element in <paramref name="source"/>.</typeparam>
            <typeparam name="TResult">
            The type of the element in the resulting array.</typeparam>
            <returns>
            An array that contains the projected elements from the input
            sequence. The size of the array will be as large as the highest
            index returned by the <paramref name="indexSelector"/> plus 1.
            </returns>
            <remarks>
            This method forces immediate query evaluation. It should not be
            used on infinite sequences. If more than one element maps to the
            same index then the latter element overwrites the former in the
            resulting array.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToArrayByIndex``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32},System.Func{``0,System.Int32,``1})">
            <summary>
            Creates an array from an <see cref="T:System.Collections.Generic.IEnumerable`1"/> where a
            function is used to determine the index at which an element will
            be placed in the array. The elements are projected into the array
            via an additional function.
            </summary>
            <param name="source">The source sequence for the array.</param>
            <param name="indexSelector">
            A function that maps an element to its index.</param>
            <param name="resultSelector">
            A function to project a source element into an element of the
            resulting array.</param>
            <typeparam name="T">
            The type of the element in <paramref name="source"/>.</typeparam>
            <typeparam name="TResult">
            The type of the element in the resulting array.</typeparam>
            <returns>
            An array that contains the projected elements from the input
            sequence. The size of the array will be as large as the highest
            index returned by the <paramref name="indexSelector"/> plus 1.
            </returns>
            <remarks>
            This method forces immediate query evaluation. It should not be
            used on infinite sequences. If more than one element maps to the
            same index then the latter element overwrites the former in the
            resulting array.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToArrayByIndex``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,System.Int32})">
            <summary>
            Creates an array of user-specified length from an
            <see cref="T:System.Collections.Generic.IEnumerable`1"/> where a function is used to determine
            the index at which an element will be placed in the array.
            </summary>
            <param name="source">The source sequence for the array.</param>
            <param name="length">The (non-negative) length of the resulting array.</param>
            <param name="indexSelector">
            A function that maps an element to its index.</param>
            <typeparam name="T">
            The type of the element in <paramref name="source"/>.</typeparam>
            <returns>
            An array of size <paramref name="length"/> that contains the
            elements from the input sequence.
            </returns>
            <remarks>
            This method forces immediate query evaluation. It should not be
            used on infinite sequences. If more than one element maps to the
            same index then the latter element overwrites the former in the
            resulting array.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToArrayByIndex``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,System.Int32},System.Func{``0,``1})">
            <summary>
            Creates an array of user-specified length from an
            <see cref="T:System.Collections.Generic.IEnumerable`1"/> where a function is used to determine
            the index at which an element will be placed in the array. The
            elements are projected into the array via an additional function.
            </summary>
            <param name="source">The source sequence for the array.</param>
            <param name="length">The (non-negative) length of the resulting array.</param>
            <param name="indexSelector">
            A function that maps an element to its index.</param>
            <param name="resultSelector">
            A function to project a source element into an element of the
            resulting array.</param>
            <typeparam name="T">
            The type of the element in <paramref name="source"/>.</typeparam>
            <typeparam name="TResult">
            The type of the element in the resulting array.</typeparam>
            <returns>
            An array of size <paramref name="length"/> that contains the
            projected elements from the input sequence.
            </returns>
            <remarks>
            This method forces immediate query evaluation. It should not be
            used on infinite sequences. If more than one element maps to the
            same index then the latter element overwrites the former in the
            resulting array.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToArrayByIndex``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,System.Int32},System.Func{``0,System.Int32,``1})">
            <summary>
            Creates an array of user-specified length from an
            <see cref="T:System.Collections.Generic.IEnumerable`1"/> where a function is used to determine
            the index at which an element will be placed in the array. The
            elements are projected into the array via an additional function.
            </summary>
            <param name="source">The source sequence for the array.</param>
            <param name="length">The (non-negative) length of the resulting array.</param>
            <param name="indexSelector">
            A function that maps an element to its index.</param>
            <param name="resultSelector">
            A function to project a source element into an element of the
            resulting array.</param>
            <typeparam name="T">
            The type of the element in <paramref name="source"/>.</typeparam>
            <typeparam name="TResult">
            The type of the element in the resulting array.</typeparam>
            <returns>
            An array of size <paramref name="length"/> that contains the
            projected elements from the input sequence.
            </returns>
            <remarks>
            This method forces immediate query evaluation. It should not be
            used on infinite sequences. If more than one element maps to the
            same index then the latter element overwrites the former in the
            resulting array.
            </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
            a given delimiter.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence</typeparam>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Boolean},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Byte},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Char},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Decimal},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Double},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Single},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Int32},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Int64},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.SByte},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Int16},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.String},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.UInt32},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.UInt64},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.UInt16},System.String)">
            <summary>
            Creates a delimited string from a sequence of values and
            a given delimiter.
            </summary>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
            <param name="delimiter">The delimiter to inject between elements.</param>
            <returns>
            A string that consists of the elements in <paramref name="source"/>
            delimited by <paramref name="delimiter"/>. If the source sequence
            is empty, the method returns an empty string.
            </returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="source"/> or <paramref name="delimiter"/> is <c>null</c>.
            </exception>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}})">
            <summary>
            Creates a <see cref="T:System.Collections.Generic.Dictionary`2" /> from a sequence of
            <see cref="T:System.Collections.Generic.KeyValuePair`2" /> elements.
            </summary>
            <typeparam name="TKey">The type of the key.</typeparam>
            <typeparam name="TValue">The type of the value.</typeparam>
            <param name="source">The source sequence of key-value pairs.</param>
            <returns>
            A <see cref="T:System.Collections.Generic.Dictionary`2"/> containing the values
            mapped to their keys.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Creates a <see cref="T:System.Collections.Generic.Dictionary`2" /> from a sequence of
            <see cref="T:System.Collections.Generic.KeyValuePair`2" /> elements. An additional
            parameter specifies a comparer for keys.
            </summary>
            <typeparam name="TKey">The type of the key.</typeparam>
            <typeparam name="TValue">The type of the value.</typeparam>
            <param name="source">The source sequence of key-value pairs.</param>
            <param name="comparer">The comparer for keys.</param>
            <returns>
            A <see cref="T:System.Collections.Generic.Dictionary`2"/> containing the values
            mapped to their keys.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}})">
            <summary>
            Creates a <see cref="T:System.Collections.Generic.Dictionary`2" /> from a sequence of
            tuples of 2 where the first item is the key and the second the
            value.
            </summary>
            <typeparam name="TKey">The type of the key.</typeparam>
            <typeparam name="TValue">The type of the value.</typeparam>
            <param name="source">The source sequence of couples (tuple of 2).</param>
            <returns>
            A <see cref="T:System.Collections.Generic.Dictionary`2"/> containing the values
            mapped to their keys.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Creates a <see cref="T:System.Collections.Generic.Dictionary`2" /> from a sequence of
            tuples of 2 where the first item is the key and the second the
            value. An additional parameter specifies a comparer for keys.
            </summary>
            <typeparam name="TKey">The type of the key.</typeparam>
            <typeparam name="TValue">The type of the value.</typeparam>
            <param name="source">The source sequence of couples (tuple of 2).</param>
            <param name="comparer">The comparer for keys.</param>
            <returns>
            A <see cref="T:System.Collections.Generic.Dictionary`2"/> containing the values
            mapped to their keys.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToHashSet``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Returns a <see cref="T:System.Collections.Generic.HashSet`1"/> of the source items using the default equality
            comparer for the type.
            </summary>
            <typeparam name="TSource">Type of elements in source sequence.</typeparam>
            <param name="source">Source sequence</param>
            <returns>A hash set of the items in the sequence, using the default equality comparer.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <remarks>
            This evaluates the input sequence completely.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToHashSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Returns a <see cref="T:System.Collections.Generic.HashSet`1"/> of the source items using the specified equality
            comparer for the type.
            </summary>
            <typeparam name="TSource">Type of elements in source sequence.</typeparam>
            <param name="source">Source sequence</param>
            <param name="comparer">Equality comparer to use; a value of null will cause the type's default equality comparer to be used</param>
            <returns>A hash set of the items in the sequence, using the default equality comparer.</returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <remarks>
            This evaluates the input sequence completely.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToLookup``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}})">
            <summary>
            Creates a <see cref="T:System.Linq.ILookup`2" /> from a sequence of
            <see cref="T:System.Collections.Generic.KeyValuePair`2" /> elements.
            </summary>
            <typeparam name="TKey">The type of the key.</typeparam>
            <typeparam name="TValue">The type of the value.</typeparam>
            <param name="source">The source sequence of key-value pairs.</param>
            <returns>
            A <see cref="T:System.Linq.ILookup`2"/> containing the values
            mapped to their keys.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToLookup``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Creates a <see cref="T:System.Linq.ILookup`2" /> from a sequence of
            <see cref="T:System.Collections.Generic.KeyValuePair`2" /> elements. An additional
            parameter specifies a comparer for keys.
            </summary>
            <typeparam name="TKey">The type of the key.</typeparam>
            <typeparam name="TValue">The type of the value.</typeparam>
            <param name="source">The source sequence of key-value pairs.</param>
            <param name="comparer">The comparer for keys.</param>
            <returns>
            A <see cref="T:System.Linq.ILookup`2"/> containing the values
            mapped to their keys.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToLookup``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}})">
            <summary>
            Creates a <see cref="T:MoreLinq.Lookup`2" /> from a sequence of
            tuples of 2 where the first item is the key and the second the
            value.
            </summary>
            <typeparam name="TKey">The type of the key.</typeparam>
            <typeparam name="TValue">The type of the value.</typeparam>
            <param name="source">The source sequence of tuples of 2.</param>
            <returns>
            A <see cref="T:MoreLinq.Lookup`2"/> containing the values
            mapped to their keys.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToLookup``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Creates a <see cref="T:MoreLinq.Lookup`2" /> from a sequence of
            tuples of 2 where the first item is the key and the second the
            value. An additional parameter specifies a comparer for keys.
            </summary>
            <typeparam name="TKey">The type of the key.</typeparam>
            <typeparam name="TValue">The type of the value.</typeparam>
            <param name="source">The source sequence of tuples of 2.</param>
            <param name="comparer">The comparer for keys.</param>
            <returns>
            A <see cref="T:MoreLinq.Lookup`2"/> containing the values
            mapped to their keys.
            </returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Trace``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Traces the elements of a source sequence for diagnostics.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence</typeparam>
            <param name="source">Source sequence whose elements to trace.</param>
            <returns>
            Return the source sequence unmodified.
            </returns>
            <remarks>
            This a pass-through operator that uses deferred execution and
            streams the results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Trace``1(System.Collections.Generic.IEnumerable{``0},System.String)">
            <summary>
            Traces the elements of a source sequence for diagnostics using
            custom formatting.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence</typeparam>
            <param name="source">Source sequence whose elements to trace.</param>
            <param name="format">
            String to use to format the trace message. If null then the
            element value becomes the traced message.
            </param>
            <returns>
            Return the source sequence unmodified.
            </returns>
            <remarks>
            This a pass-through operator that uses deferred execution and
            streams the results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Trace``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.String})">
            <summary>
            Traces the elements of a source sequence for diagnostics using
            a custom formatter.
            </summary>
            <typeparam name="TSource">Type of element in the source sequence</typeparam>
            <param name="source">Source sequence whose elements to trace.</param>
            <param name="formatter">Function used to format each source element into a string.</param>
            <returns>
            Return the source sequence unmodified.
            </returns>
            <remarks>
            This a pass-through operator that uses deferred execution and
            streams the results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Transpose``1(System.Collections.Generic.IEnumerable{System.Collections.Generic.IEnumerable{``0}})">
            <summary>
            Transposes a sequence of rows into a sequence of columns.
            </summary>
            <typeparam name="T">Type of source sequence elements.</typeparam>
            <param name="source">Source sequence to transpose.</param>
            <returns>
            Returns a sequence of columns in the source swapped into rows.
            </returns>
            <remarks>
            If a rows is shorter than a follow it then the shorter row's
            elements are skipped in the corresponding column sequences.
            This operator uses deferred execution and streams its results.
            Source sequence is consumed greedily when an iteration begins.
            The inner sequences representing rows are consumed lazily and
            resulting sequences of columns are streamed.
            </remarks>
            <example>
            <code><![CDATA[
            var matrix = new[]
            {
                new[] { 10, 11 },
                new[] { 20 },
                new[] { 30, 31, 32 }
            };
            var result = matrix.Transpose();
            ]]></code>
            The <c>result</c> variable will contain [[10, 20, 30], [11, 31], [32]].
            </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.TraverseBreadthFirst``1(``0,System.Func{``0,System.Collections.Generic.IEnumerable{``0}})">
            <summary>
            Traverses a tree in a breadth-first fashion, starting at a root
            node and using a user-defined function to get the children at each
            node of the tree.
            </summary>
            <typeparam name="T">The tree node type</typeparam>
            <param name="root">The root of the tree to traverse.</param>
            <param name="childrenSelector">
            The function that produces the children of each element.</param>
            <returns>A sequence containing the traversed values.</returns>
            <remarks>
            <para>
            The tree is not checked for loops. If the resulting sequence needs
            to be finite then it is the responsibility of
            <paramref name="childrenSelector"/> to ensure that loops are not
            produced.</para>
            <para>
            This function defers traversal until needed and streams the
            results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.TraverseDepthFirst``1(``0,System.Func{``0,System.Collections.Generic.IEnumerable{``0}})">
            <summary>
            Traverses a tree in a depth-first fashion, starting at a root node
            and using a user-defined function to get the children at each node
            of the tree.
            </summary>
            <typeparam name="T">The tree node type.</typeparam>
            <param name="root">The root of the tree to traverse.</param>
            <param name="childrenSelector">
            The function that produces the children of each element.</param>
            <returns>A sequence containing the traversed values.</returns>
            <remarks>
            <para>
            The tree is not checked for loops. If the resulting sequence needs
            to be finite then it is the responsibility of
            <paramref name="childrenSelector"/> to ensure that loops are not
            produced.</para>
            <para>
            This function defers traversal until needed and streams the
            results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Unfold``3(``0,System.Func{``0,``1},System.Func{``1,System.Boolean},System.Func{``1,``0},System.Func{``1,``2})">
            <summary>
            Returns a sequence generated by applying a state to the generator function,
            and from its result, determines if the sequence should have a next element, its value,
            and the next state in the recursive call.
            </summary>
            <typeparam name="TState">Type of state elements.</typeparam>
            <typeparam name="T">Type of the elements generated by the generator function.</typeparam>
            <typeparam name="TResult">The type of the elements of the result sequence.</typeparam>
            <param name="state">The initial state.</param>
            <param name="generator">
            Function that takes a state and computes the next state and the next element of the sequence.
            </param>
            <param name="predicate">
            Function to determine if the unfolding should continue based the
            result of the <paramref name="generator"/> function.
            </param>
            <param name="stateSelector">
            Function to select the state from the output of the <paramref name="generator"/> function.
            </param>
            <param name="resultSelector">
            Function to select the result from the output of the <paramref name="generator"/> function.
            </param>
            <returns>A sequence containing the results generated by the <paramref name="resultSelector"/> function.</returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Window``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Processes a sequence into a series of subsequences representing a windowed subset of the original
            </summary>
            <remarks>
            The number of sequences returned is: <c>Max(0, sequence.Count() - windowSize) + 1</c><br/>
            Returned subsequences are buffered, but the overall operation is streamed.<br/>
            </remarks>
            <typeparam name="TSource">The type of the elements of the source sequence</typeparam>
            <param name="source">The sequence to evaluate a sliding window over</param>
            <param name="size">The size (number of elements) in each window</param>
            <returns>A series of sequences representing each sliding window subsequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Windowed``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Processes a sequence into a series of subsequences representing a windowed subset of the original
            </summary>
            <remarks>
            The number of sequences returned is: <c>Max(0, sequence.Count() - windowSize) + 1</c><br/>
            Returned subsequences are buffered, but the overall operation is streamed.<br/>
            </remarks>
            <typeparam name="TSource">The type of the elements of the source sequence</typeparam>
            <param name="source">The sequence to evaluate a sliding window over</param>
            <param name="size">The size (number of elements) in each window</param>
            <returns>A series of sequences representing each sliding window subsequence</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.WindowLeft``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
             <summary>
             Creates a left-aligned sliding window of a given size over the
             source sequence.
             </summary>
             <typeparam name="TSource">
             The type of the elements of <paramref name="source"/>.</typeparam>
             <param name="source">
             The sequence over which to create the sliding window.</param>
             <param name="size">Size of the sliding window.</param>
             <returns>A sequence representing each sliding window.</returns>
             <remarks>
             <para>
             A window can contain fewer elements than <paramref name="size"/>,
             especially as it slides over the end of the sequence.</para>
             <para>
             This operator uses deferred execution and streams its results.</para>
             </remarks>
             <example>
             <code><![CDATA[
             Console.WriteLine(
                 Enumerable
                     .Range(1, 5)
                     .WindowLeft(3)
                     .Select(w => "AVG(" + w.ToDelimitedString(",") + ") = " + w.Average())
                     .ToDelimitedString(Environment.NewLine));
             
             // Output:
             // AVG(1,2,3) = 2
             // AVG(2,3,4) = 3
             // AVG(3,4,5) = 4
             // AVG(4,5) = 4.5
             // AVG(5) = 5
             ]]></code>
             </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.WindowRight``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
             <summary>
             Creates a right-aligned sliding window over the source sequence
             of a given size.
             </summary>
             <typeparam name="TSource">
             The type of the elements of <paramref name="source"/>.</typeparam>
             <param name="source">
             The sequence over which to create the sliding window.</param>
             <param name="size">Size of the sliding window.</param>
             <returns>A sequence representing each sliding window.</returns>
             <remarks>
             <para>
             A window can contain fewer elements than <paramref name="size"/>,
             especially as it slides over the start of the sequence.</para>
             <para>
             This operator uses deferred execution and streams its results.</para>
             </remarks>
             <example>
             <code><![CDATA[
             Console.WriteLine(
                 Enumerable
                     .Range(1, 5)
                     .WindowRight(3)
                     .Select(w => "AVG(" + w.ToDelimitedString(",") + ") = " + w.Average())
                     .ToDelimitedString(Environment.NewLine));
             
             // Output:
             // AVG(1) = 1
             // AVG(1,2) = 1.5
             // AVG(1,2,3) = 2
             // AVG(2,3,4) = 3
             // AVG(3,4,5) = 4
             ]]></code>
             </example>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.WindowRightWhile``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Int32,System.Boolean})">
            <summary>
            Creates a right-aligned sliding window over the source sequence
            with a predicate function determining the window range.
            </summary>
        </member>
        <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. 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>
            <typeparam name="TResult">Type of elements in result sequence.</typeparam>
            <param name="first">The first sequence.</param>
            <param name="second">The second sequence.</param>
            <param name="resultSelector">
            Function to apply to each pair of elements.</param>
            <returns>
            A sequence that contains elements of the two input sequences,
            combined by <paramref name="resultSelector"/>.
            </returns>
            <example>
            <code><![CDATA[
            var numbers = { 1, 2, 3 };
            var letters = { "A", "B", "C", "D" };
            var zipped = numbers.ZipLongest(letters, (n, l) => n + l);
            ]]></code>
            The <c>zipped</c> variable, when iterated over, will yield "1A",
            "2B", "3C", "0D" in turn.
            </example>
            <remarks>
            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. 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>
            <typeparam name="T3">Type of elements in third sequence.</typeparam>
            <typeparam name="TResult">Type of elements in result sequence.</typeparam>
            <param name="first">The first sequence.</param>
            <param name="second">The second sequence.</param>
            <param name="third">The third sequence.</param>
            <param name="resultSelector">
            Function to apply to each triplet of elements.</param>
            <returns>
            A sequence that contains elements of the three input sequences,
            combined by <paramref name="resultSelector"/>.
            </returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 1, 2, 3 };
            var letters = new[] { "A", "B", "C", "D" };
            var chars = new[] { 'a', 'b', 'c', 'd', 'e' };
            var zipped = numbers.ZipLongest(letters, chars, (n, l, c) => n + l + c);
            ]]></code>
            The <c>zipped</c> variable, when iterated over, will yield "1Aa",
            "2Bb", "3Cc", "0Dd", "0e" in turn.
            </example>
            <remarks>
            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. 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>
            <typeparam name="T3">Type of elements in third sequence</typeparam>
            <typeparam name="T4">Type of elements in fourth sequence</typeparam>
            <typeparam name="TResult">Type of elements in result sequence</typeparam>
            <param name="first">The first sequence.</param>
            <param name="second">The second sequence.</param>
            <param name="third">The third sequence.</param>
            <param name="fourth">The fourth sequence.</param>
            <param name="resultSelector">
            Function to apply to each quadruplet of elements.</param>
            <returns>
            A sequence that contains elements of the four input sequences,
            combined by <paramref name="resultSelector"/>.
            </returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 1, 2, 3 };
            var letters = new[] { "A", "B", "C", "D" };
            var chars = new[] { 'a', 'b', 'c', 'd', 'e' };
            var flags = new[] { true, false, true, false, true, false };
            var zipped = numbers.ZipLongest(letters, chars, flags, (n, l, c, f) => n + l + c + f);
            ]]></code>
            The <c>zipped</c> variable, when iterated over, will yield "1AaTrue",
            "2BbFalse", "3CcTrue", "0DdFalse", "0eTrue", "0\0False" in turn.
            </example>
            <remarks>
            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. 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>
            <typeparam name="TResult">Type of elements in result sequence.</typeparam>
            <param name="first">The first sequence.</param>
            <param name="second">The second sequence.</param>
            <param name="resultSelector">
            Function to apply to each pair of elements.</param>
            <returns>
            A projection of tuples, where each tuple contains the N-th element
            from each of the argument sequences.</returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 1, 2, 3 };
            var letters = new[] { "A", "B", "C", "D" };
            var zipped = numbers.ZipShortest(letters, (n, l) => n + l);
            ]]></code>
            The <c>zipped</c> variable, when iterated over, will yield "1A", "2B", "3C", in turn.
            </example>
            <remarks>
            <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>
        </member>
        <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. 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>
            <typeparam name="T3">Type of elements in third sequence.</typeparam>
            <typeparam name="TResult">Type of elements in result sequence.</typeparam>
            <param name="first">First sequence</param>
            <param name="second">Second sequence</param>
            <param name="third">Third sequence</param>
            <param name="resultSelector">
            Function to apply to each triplet of elements.</param>
            <returns>
            A projection of tuples, where each tuple contains the N-th element
            from each of the argument sequences.</returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 1, 2, 3 };
            var letters = new[] { "A", "B", "C", "D" };
            var chars = new[] { 'a', 'b', 'c', 'd', 'e' };
            var zipped = numbers.ZipShortest(letters, chars, (n, l, c) => c + n + l);
            ]]></code>
            The <c>zipped</c> variable, when iterated over, will yield
            "98A", "100B", "102C", in turn.
            </example>
            <remarks>
            <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>
        </member>
        <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. 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>
            <typeparam name="T3">Type of elements in third sequence.</typeparam>
            <typeparam name="T4">Type of elements in fourth sequence.</typeparam>
            <typeparam name="TResult">Type of elements in result sequence.</typeparam>
            <param name="first">The first sequence.</param>
            <param name="second">The second sequence.</param>
            <param name="third">The third sequence.</param>
            <param name="fourth">The fourth sequence.</param>
            <param name="resultSelector">
            Function to apply to each quadruplet of elements.</param>
            <returns>
            A projection of tuples, where each tuple contains the N-th element
            from each of the argument sequences.</returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 1, 2, 3 };
            var letters = new[] { "A", "B", "C", "D" };
            var chars = new[] { 'a', 'b', 'c', 'd', 'e' };
            var flags = new[] { true, false };
            var zipped = numbers.ZipShortest(letters, chars, flags, (n, l, c, f) => n + l + c + f);
            ]]></code>
            The <c>zipped</c> variable, when iterated over, will yield
            "1AaTrue", "2BbFalse" in turn.
            </example>
            <remarks>
            <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>
        </member>
        <member name="T:MoreLinq.Experimental.ExperimentalEnumerable">
            <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>
            </summary>
        </member>
        <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>
            Applies two 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="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.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>
            Applies three 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="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.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.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 five 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="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.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 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.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.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>
            <param name="source">Source sequence.</param>
            <param name="seed">The initial accumulator value.</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[
            var numbers = Enumerable.Range(1, 5);
            string result = numbers.AggregateRight("6", (a, b) => string.Format("({0}/{1})", a, b));
            ]]></code>
            The <c>result</c> variable will contain <c>"(1/(2/(3/(4/(5/6)))))"</c>.
            </example>
            <remarks>
            This operator executes immediately.
            </remarks>
        </member>
        <member name="M:MoreLinq.Extensions.AggregateRightExtension.AggregateRight``3(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``0,``1,``1},System.Func{``1,``2})">
            <summary>
            Applies a right-associative accumulator function over a sequence.
            The specified seed value is used as the initial accumulator value,
            and the specified function is used to select the result value.
            This operator is the right-associative version of the
            <see cref="M:System.Linq.Enumerable.Aggregate``3(System.Collections.Generic.IEnumerable{``0},``1,System.Func{``1,``0,``1},System.Func{``1,``2})"/> LINQ operator.
            </summary>
            <typeparam name="TSource">The type of the elements of source.</typeparam>
            <typeparam name="TAccumulate">The type of the accumulator value.</typeparam>
            <typeparam name="TResult">The type of the resulting value.</typeparam>
            <param name="source">Source sequence.</param>
            <param name="seed">The initial accumulator value.</param>
            <param name="func">A right-associative accumulator function to be invoked on each element.</param>
            <param name="resultSelector">A function to transform the final accumulator value into the result value.</param>
            <returns>The transformed final accumulator value.</returns>
            <example>
            <code><![CDATA[
            var numbers = Enumerable.Range(1, 5);
            int result = numbers.AggregateRight("6", (a, b) => string.Format("({0}/{1})", a, b), str => str.Length);
            ]]></code>
            The <c>result</c> variable will contain <c>21</c>.
            </example>
            <remarks>
            This operator executes immediately.
            </remarks>
        </member>
        <member name="T:MoreLinq.Extensions.AppendExtension">
            <summary><c>Append</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.AppendExtension.Append``1(System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Returns a sequence consisting of the head elements and the given tail element.
            </summary>
            <typeparam name="T">Type of sequence</typeparam>
            <param name="head">All elements of the head. Must not be null.</param>
            <param name="tail">Tail element of the new sequence.</param>
            <returns>A sequence consisting of the head elements and the given tail element.</returns>
            <remarks>This operator uses deferred execution and streams its results.</remarks>
        </member>
        <member name="T:MoreLinq.Extensions.AssertExtension">
            <summary><c>Assert</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.AssertExtension.Assert``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
            <summary>
            Asserts that all elements of a sequence meet a given condition
            otherwise throws an <see cref="T:System.Exception"/> object.
            </summary>
            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
            <param name="source">Source sequence.</param>
            <param name="predicate">Function that asserts an element of the <paramref name="source"/> sequence for a condition.</param>
            <returns>
            Returns the original sequence.
            </returns>
            <exception cref="T:System.InvalidOperationException">The input sequence
            contains an element that does not meet the condition being
            asserted.</exception>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="M:MoreLinq.Extensions.AssertExtension.Assert``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean},System.Func{``0,System.Exception})">
            <summary>
            Asserts that all elements of a sequence meet a given condition
            otherwise throws an <see cref="T:System.Exception"/> object.
            </summary>
            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
            <param name="source">Source sequence.</param>
            <param name="predicate">Function that asserts an element of the input sequence for a condition.</param>
            <param name="errorSelector">Function that returns the <see cref="T:System.Exception"/> object to throw.</param>
            <returns>
            Returns the original sequence.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="T:MoreLinq.Extensions.AssertCountExtension">
            <summary><c>AssertCount</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.AssertCountExtension.AssertCount``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Asserts that a source sequence contains a given count of elements.
            </summary>
            <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>
            <returns>
            Returns the original sequence as long it is contains the
            number of elements specified by <paramref name="count"/>.
            Otherwise it throws <see cref="T:System.Exception" />.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="M:MoreLinq.Extensions.AssertCountExtension.AssertCount``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Int32,System.Int32,System.Exception})">
            <summary>
            Asserts that a source sequence contains a given count of elements.
            A parameter specifies the exception to be thrown.
            </summary>
            <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 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"/>.
            Otherwise it throws the <see cref="T:System.Exception" /> object
            returned by calling <paramref name="errorSelector"/>.
            </returns>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="T:MoreLinq.Extensions.AtLeastExtension">
            <summary><c>AtLeast</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.AtLeastExtension.AtLeast``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Determines whether or not the number of elements in the sequence is greater than
            or equal to the given integer.
            </summary>
            <typeparam name="T">Element type of sequence</typeparam>
            <param name="source">The source sequence</param>
            <param name="count">The minimum number of items a sequence must have for this
            function to return true</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative</exception>
            <returns><c>true</c> if the number of elements in the sequence is greater than
            or equal to the given integer or <c>false</c> otherwise.</returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 123, 456, 789 };
            var result = numbers.AtLeast(2);
            ]]></code>
            The <c>result</c> variable will contain <c>true</c>.
            </example>
        </member>
        <member name="T:MoreLinq.Extensions.AtMostExtension">
            <summary><c>AtMost</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.AtMostExtension.AtMost``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Determines whether or not the number of elements in the sequence is lesser than
            or equal to the given integer.
            </summary>
            <typeparam name="T">Element type of sequence</typeparam>
            <param name="source">The source sequence</param>
            <param name="count">The maximun number of items a sequence must have for this
            function to return true</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative</exception>
            <returns><c>true</c> if the number of elements in the sequence is lesser than
            or equal to the given integer or <c>false</c> otherwise.</returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 123, 456, 789 };
            var result = numbers.AtMost(2);
            ]]></code>
            The <c>result</c> variable will contain <c>false</c>.
            </example>
        </member>
        <member name="T:MoreLinq.Extensions.BacksertExtension">
            <summary><c>Backsert</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.BacksertExtension.Backsert``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
            specified index from the tail of the sequence, where zero always
            represents the last position, one represents the second-last
            element, two represents the third-last element and so on.
            </summary>
            <typeparam name="T">
            Type of elements in all sequences.</typeparam>
            <param name="first">The source sequence.</param>
            <param name="second">The sequence that will be inserted.</param>
            <param name="index">
            The zero-based index from the end of <paramref name="first"/> where
            elements from <paramref name="second"/> should be inserted.
            <paramref name="second"/>.</param>
            <returns>
            A sequence that contains the elements of <paramref name="first"/>
            plus the elements of <paramref name="second"/> inserted at
            the given index from the end of <paramref name="first"/>.
            </returns>
            <exception cref="T:System.ArgumentNullException"><paramref name="first"/> is null.</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="second"/> is null.</exception>
            <exception cref="T:System.ArgumentOutOfRangeException">
            Thrown if <paramref name="index"/> is negative.
            </exception>
            <exception cref="T:System.ArgumentOutOfRangeException">
            Thrown lazily if <paramref name="index"/> is greater than the
            length of <paramref name="first"/>. The validation occurs when
            the resulting sequence is iterated.
            </exception>
            <remarks>
            This method uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="T:MoreLinq.Extensions.BatchExtension">
            <summary><c>Batch</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.BatchExtension.Batch``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Batches the source sequence into sized buckets.
            </summary>
            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="size">Size of buckets.</param>
            <returns>A sequence of equally sized buckets containing elements of the source collection.</returns>
            <remarks>
            This operator uses deferred execution and streams its results (buckets and bucket content).
            </remarks>
        </member>
        <member name="M:MoreLinq.Extensions.BatchExtension.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1})">
            <summary>
            Batches the source sequence into sized buckets and applies a projection to each bucket.
            </summary>
            <typeparam name="TSource">Type of elements in <paramref name="source"/> sequence.</typeparam>
            <typeparam name="TResult">Type of result returned by <paramref name="resultSelector"/>.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="size">Size of buckets.</param>
            <param name="resultSelector">The projection to apply to each bucket.</param>
            <returns>A sequence of projections on equally sized buckets containing elements of the source collection.</returns>
            <remarks>
            This operator uses deferred execution and streams its results (buckets and bucket content).
            </remarks>
        </member>
        <member name="T:MoreLinq.Extensions.CartesianExtension">
            <summary><c>Cartesian</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``3(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Func{``0,``1,``2})">
            <summary>
            Returns the Cartesian product of two sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``4(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Func{``0,``1,``2,``3})">
            <summary>
            Returns the Cartesian product of three sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="T3">
            The type of the elements of <paramref name="third"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="third">The third sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``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 the Cartesian product of four sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="T3">
            The type of the elements of <paramref name="third"/>.</typeparam>
            <typeparam name="T4">
            The type of the elements of <paramref name="fourth"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="third">The third sequence of elements.</param>
            <param name="fourth">The fourth sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``6(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Func{``0,``1,``2,``3,``4,``5})">
            <summary>
            Returns the Cartesian product of five sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="T3">
            The type of the elements of <paramref name="third"/>.</typeparam>
            <typeparam name="T4">
            The type of the elements of <paramref name="fourth"/>.</typeparam>
            <typeparam name="T5">
            The type of the elements of <paramref name="fifth"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="third">The third sequence of elements.</param>
            <param name="fourth">The fourth sequence of elements.</param>
            <param name="fifth">The fifth sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``7(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Collections.Generic.IEnumerable{``5},System.Func{``0,``1,``2,``3,``4,``5,``6})">
            <summary>
            Returns the Cartesian product of six sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="T3">
            The type of the elements of <paramref name="third"/>.</typeparam>
            <typeparam name="T4">
            The type of the elements of <paramref name="fourth"/>.</typeparam>
            <typeparam name="T5">
            The type of the elements of <paramref name="fifth"/>.</typeparam>
            <typeparam name="T6">
            The type of the elements of <paramref name="sixth"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="third">The third sequence of elements.</param>
            <param name="fourth">The fourth sequence of elements.</param>
            <param name="fifth">The fifth sequence of elements.</param>
            <param name="sixth">The sixth sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``8(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Collections.Generic.IEnumerable{``5},System.Collections.Generic.IEnumerable{``6},System.Func{``0,``1,``2,``3,``4,``5,``6,``7})">
            <summary>
            Returns the Cartesian product of seven sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="T3">
            The type of the elements of <paramref name="third"/>.</typeparam>
            <typeparam name="T4">
            The type of the elements of <paramref name="fourth"/>.</typeparam>
            <typeparam name="T5">
            The type of the elements of <paramref name="fifth"/>.</typeparam>
            <typeparam name="T6">
            The type of the elements of <paramref name="sixth"/>.</typeparam>
            <typeparam name="T7">
            The type of the elements of <paramref name="seventh"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="third">The third sequence of elements.</param>
            <param name="fourth">The fourth sequence of elements.</param>
            <param name="fifth">The fifth sequence of elements.</param>
            <param name="sixth">The sixth sequence of elements.</param>
            <param name="seventh">The seventh sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="M:MoreLinq.Extensions.CartesianExtension.Cartesian``9(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1},System.Collections.Generic.IEnumerable{``2},System.Collections.Generic.IEnumerable{``3},System.Collections.Generic.IEnumerable{``4},System.Collections.Generic.IEnumerable{``5},System.Collections.Generic.IEnumerable{``6},System.Collections.Generic.IEnumerable{``7},System.Func{``0,``1,``2,``3,``4,``5,``6,``7,``8})">
            <summary>
            Returns the Cartesian product of eight sequences by enumerating all
            possible combinations of one item from each sequence, and applying
            a user-defined projection to the items in a given combination.
            </summary>
            <typeparam name="T1">
            The type of the elements of <paramref name="first"/>.</typeparam>
            <typeparam name="T2">
            The type of the elements of <paramref name="second"/>.</typeparam>
            <typeparam name="T3">
            The type of the elements of <paramref name="third"/>.</typeparam>
            <typeparam name="T4">
            The type of the elements of <paramref name="fourth"/>.</typeparam>
            <typeparam name="T5">
            The type of the elements of <paramref name="fifth"/>.</typeparam>
            <typeparam name="T6">
            The type of the elements of <paramref name="sixth"/>.</typeparam>
            <typeparam name="T7">
            The type of the elements of <paramref name="seventh"/>.</typeparam>
            <typeparam name="T8">
            The type of the elements of <paramref name="eighth"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements of the result sequence.</typeparam>
            <param name="first">The first sequence of elements.</param>
            <param name="second">The second sequence of elements.</param>
            <param name="third">The third sequence of elements.</param>
            <param name="fourth">The fourth sequence of elements.</param>
            <param name="fifth">The fifth sequence of elements.</param>
            <param name="sixth">The sixth sequence of elements.</param>
            <param name="seventh">The seventh sequence of elements.</param>
            <param name="eighth">The eighth sequence of elements.</param>
            <param name="resultSelector">A projection function that combines
            elements from all of the sequences.</param>
            <returns>A sequence of elements returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            <para>
            The method returns items in the same order as a nested foreach
            loop, but all sequences except for <paramref name="first"/> are
            cached when iterated over. The cache is then re-used for any
            subsequent iterations.</para>
            <para>
            This method uses deferred execution and stream its results.</para>
            </remarks>
        </member>
        <member name="T:MoreLinq.Extensions.ChooseExtension">
            <summary><c>Choose</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.ChooseExtension.Choose``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.ValueTuple{System.Boolean,``1}})">
            <summary>
            Applies a function to each element of the source sequence and
            returns a new sequence of result elements for source elements
            where the function returns a couple (2-tuple) having a <c>true</c>
            as its first element and result as the second.
            </summary>
            <typeparam name="T">
            The type of the elements in <paramref name="source"/>.</typeparam>
            <typeparam name="TResult">
            The type of the elements in the returned sequence.</typeparam>
            <param name="source"> The source sequence.</param>
            <param name="chooser">The function that is applied to each source
            element.</param>
            <returns>A sequence <typeparamref name="TResult"/> elements.</returns>
            <remarks>
            This method uses deferred execution semantics and streams its
            results.
            </remarks>
            <example>
            <code><![CDATA[
            var str = "O,l,2,3,4,S,6,7,B,9";
            var xs = str.Split(',').Choose(s => (int.TryParse(s, out var n), n));
            ]]></code>
            The <c>xs</c> variable will be a sequence of the integers 2, 3, 4,
            6, 7 and 9.
            </example>
        </member>
        <member name="T:MoreLinq.Extensions.CompareCountExtension">
            <summary><c>CompareCount</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.CompareCountExtension.CompareCount``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})">
            <summary>
            Compares two sequences and returns an integer that indicates whether the first sequence
            has fewer, the same or more elements than the second sequence.
            </summary>
            <typeparam name="TFirst">Element type of the first sequence</typeparam>
            <typeparam name="TSecond">Element type of the second sequence</typeparam>
            <param name="first">The first sequence</param>
            <param name="second">The second sequence</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="first"/> is null</exception>
            <exception cref="T:System.ArgumentNullException"><paramref name="second"/> is null</exception>
            <returns><c>-1</c> if the first sequence has the fewest elements, <c>0</c> if the two sequences have the same number of elements
            or <c>1</c> if the first sequence has the most elements.</returns>
            <example>
            <code><![CDATA[
            var first = new[] { 123, 456 };
            var second = new[] { 789 };
            var result = first.CompareCount(second);
            ]]></code>
            The <c>result</c> variable will contain <c>1</c>.
            </example>
        </member>
        <member name="T:MoreLinq.Extensions.ConsumeExtension">
            <summary><c>Consume</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.ConsumeExtension.Consume``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Completely consumes the given sequence. This method uses immediate execution,
            and doesn't store any data during execution.
            </summary>
            <typeparam name="T">Element type of the sequence</typeparam>
            <param name="source">Source to consume</param>
        </member>
        <member name="T:MoreLinq.Extensions.CountBetweenExtension">
            <summary><c>CountBetween</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.CountBetweenExtension.CountBetween``1(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Int32)">
            <summary>
            Determines whether or not the number of elements in the sequence is between
            an inclusive range of minimum and maximum integers.
            </summary>
            <typeparam name="T">Element type of sequence</typeparam>
            <param name="source">The source sequence</param>
            <param name="min">The minimum number of items a sequence must have for this
            function to return true</param>
            <param name="max">The maximun number of items a sequence must have for this
            function to return true</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="min"/> is negative or <paramref name="max"/> is less than min</exception>
            <returns><c>true</c> if the number of elements in the sequence is between (inclusive)
            the min and max given integers or <c>false</c> otherwise.</returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 123, 456, 789 };
            var result = numbers.CountBetween(1, 2);
            ]]></code>
            The <c>result</c> variable will contain <c>false</c>.
            </example>
        </member>
        <member name="T:MoreLinq.Extensions.CountByExtension">
            <summary><c>CountBy</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.CountByExtension.CountBy``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 of
            unique keys and their number of occurrences in the original sequence.
            </summary>
            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
            <typeparam name="TKey">Type of the projected element.</typeparam>
            <param name="source">Source sequence.</param>
            <param name="keySelector">Function that transforms each item of source sequence into a key to be compared against the others.</param>
            <returns>A sequence of unique keys and their number of occurrences in the original sequence.</returns>
        </member>
        <member name="M:MoreLinq.Extensions.CountByExtension.CountBy``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 of
            unique keys and their number of occurrences in the original sequence.
            An additional argument specifies a comparer to use for testing equivalence of keys.
            </summary>
            <typeparam name="TSource">Type of the elements of the source sequence.</typeparam>
            <typeparam name="TKey">Type of the projected element.</typeparam>
            <param name="source">Source sequence.</param>
            <param name="keySelector">Function that transforms each item of source sequence into a key to be compared against the others.</param>
            <param name="comparer">The equality comparer to use to determine whether or not keys are equal.
            If null, the default equality comparer for <typeparamref name="TSource"/> is used.</param>
            <returns>A sequence of unique keys and their number of occurrences in the original sequence.</returns>
        </member>
        <member name="T:MoreLinq.Extensions.CountDownExtension">
            <summary><c>CountDown</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.CountDownExtension.CountDown``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{``0,System.Nullable{System.Int32},``1})">
            <summary>
            Provides a countdown counter for a given count of elements at the
            tail of the sequence where zero always represents the last element,
            one represents the second-last element, two represents the
            third-last element and so on.
            </summary>
            <typeparam name="T">
            The type of elements of <paramref name="source"/></typeparam>
            <typeparam name="TResult">
            The type of elements of the resulting sequence.</typeparam>
            <param name="source">The source sequence.</param>
            <param name="count">Count of tail elements of
            <paramref name="source"/> to count down.</param>
            <param name="resultSelector">
            A function that receives the element and the current countdown
            value for the element and which returns those mapped to a
            result returned in the resulting sequence. For elements before
            the last <paramref name="count"/>, the coundown value is
            <c>null</c>.</param>
            <returns>
            A sequence of results returned by
            <paramref name="resultSelector"/>.</returns>
            <remarks>
            This method uses deferred execution semantics and streams its
            results. At most, <paramref name="count"/> elements of the source
            sequence may be buffered at any one time unless
            <paramref name="source"/> is a collection or a list.
            </remarks>
        </member>
        <member name="T:MoreLinq.Extensions.DistinctByExtension">
            <summary><c>DistinctBy</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.DistinctByExtension.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Returns all distinct elements of the given source, where "distinctness"
            is determined via a projection and the default equality comparer for the projected type.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results, although
            a set of already-seen keys is retained. If a key is seen multiple times,
            only the first element with that key is returned.
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="keySelector">Projection for determining "distinctness"</param>
            <returns>A sequence consisting of distinct elements from the source sequence,
            comparing them by the specified key projection.</returns>
        </member>
        <member name="M:MoreLinq.Extensions.DistinctByExtension.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Returns all distinct elements of the given source, where "distinctness"
            is determined via a projection and the specified comparer for the projected type.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results, although
            a set of already-seen keys is retained. If a key is seen multiple times,
            only the first element with that key is returned.
            </remarks>
            <typeparam name="TSource">Type of the source sequence</typeparam>
            <typeparam name="TKey">Type of the projected element</typeparam>
            <param name="source">Source sequence</param>
            <param name="keySelector">Projection for determining "distinctness"</param>
            <param name="comparer">The equality comparer to use to determine whether or not keys are equal.
            If null, the default equality comparer for <c>TSource</c> is used.</param>
            <returns>A sequence consisting of distinct elements from the source sequence,
            comparing them by the specified key projection.</returns>
        </member>
        <member name="T:MoreLinq.Extensions.EndsWithExtension">
            <summary><c>EndsWith</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.EndsWithExtension.EndsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Determines whether the end of the first sequence is equivalent to
            the second sequence, using the default equality comparer.
            </summary>
            <typeparam name="T">Type of elements.</typeparam>
            <param name="first">The sequence to check.</param>
            <param name="second">The sequence to compare to.</param>
            <returns>
            <c>true</c> if <paramref name="first" /> ends with elements
            equivalent to <paramref name="second" />.
            </returns>
            <remarks>
            This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
            <see cref="M:System.String.EndsWith(System.String)" /> and
            it calls <see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> using
            <see cref="P:System.Collections.Generic.EqualityComparer`1.Default" /> on pairs of elements at
            the same index.
            </remarks>
        </member>
        <member name="M:MoreLinq.Extensions.EndsWithExtension.EndsWith``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0})">
            <summary>
            Determines whether the end of the first sequence is equivalent to
            the second sequence, using the specified element equality comparer.
            </summary>
            <typeparam name="T">Type of elements.</typeparam>
            <param name="first">The sequence to check.</param>
            <param name="second">The sequence to compare to.</param>
            <param name="comparer">Equality comparer to use.</param>
            <returns>
            <c>true</c> if <paramref name="first" /> ends with elements
            equivalent to <paramref name="second" />.
            </returns>
            <remarks>
            This is the <see cref="T:System.Collections.Generic.IEnumerable`1" /> equivalent of
            <see cref="M:System.String.EndsWith(System.String)" /> and it calls
            <see cref="M:System.Collections.Generic.IEqualityComparer`1.Equals(`0,`0)" /> on pairs of
            elements at the same index.
            </remarks>
        </member>
        <member name="T:MoreLinq.Extensions.EquiZipExtension">
            <summary><c>EquiZip</c> extension.</summary>
        </member>
        <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. 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>
            <typeparam name="TResult">Type of elements in result sequence.</typeparam>
            <param name="first">The first sequence.</param>
            <param name="second">The second sequence.</param>
            <param name="resultSelector">
            Function to apply to each pair of elements.</param>
            <returns>
            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 };
            var letters = new[] { "A", "B", "C", "D" };
            var zipped = numbers.EquiZip(letters, (n, l) => n + l);
            ]]></code>
            The <c>zipped</c> variable, when iterated over, will yield "1A",
            "2B", "3C", "4D" in turn.
            </example>
            <remarks>
            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. 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>
            <typeparam name="T3">Type of elements in third sequence.</typeparam>
            <typeparam name="TResult">Type of elements in result sequence.</typeparam>
            <param name="first">The first sequence.</param>
            <param name="second">The second sequence.</param>
            <param name="third">The third sequence.</param>
            <param name="resultSelector">
            Function to apply to each triplet of elements.</param>
            <returns>
            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 };
            var letters = new[] { "A", "B", "C", "D" };
            var chars = new[] { 'a', 'b', 'c', 'd' };
            var zipped = numbers.EquiZip(letters, chars, (n, l, c) => n + l + c);
            ]]></code>
            The <c>zipped</c> variable, when iterated over, will yield "1Aa",
            "2Bb", "3Cc", "4Dd" in turn.
            </example>
            <remarks>
            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. 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>
            <typeparam name="T3">Type of elements in third sequence</typeparam>
            <typeparam name="T4">Type of elements in fourth sequence</typeparam>
            <typeparam name="TResult">Type of elements in result sequence</typeparam>
            <param name="first">The first sequence.</param>
            <param name="second">The second sequence.</param>
            <param name="third">The third sequence.</param>
            <param name="fourth">The fourth sequence.</param>
            <param name="resultSelector">
            Function to apply to each quadruplet of elements.</param>
            <returns>
            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 };
            var letters = new[] { "A", "B", "C", "D" };
            var chars = new[] { 'a', 'b', 'c', 'd' };
            var flags = new[] { true, false, true, false };
            var zipped = numbers.EquiZip(letters, chars, flags, (n, l, c, f) => n + l + c + f);
            ]]></code>
            The <c>zipped</c> variable, when iterated over, will yield "1AaTrue",
            "2BbFalse", "3CcTrue", "4DdFalse" in turn.
            </example>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
        </member>
        <member name="T:MoreLinq.Extensions.EvaluateExtension">
            <summary><c>Evaluate</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.EvaluateExtension.Evaluate``1(System.Collections.Generic.IEnumerable{System.Func{``0}})">
            <summary>
            Returns a sequence containing the values resulting from invoking (in order) each function in the source sequence of functions.
            </summary>
            <remarks>
            This operator uses deferred execution and streams the results.
            If the resulting sequence is enumerated multiple times, the functions will be
            evaluated multiple times too.
            </remarks>
            <typeparam name="T">The type of the object returned by the functions.</typeparam>
            <param name="functions">The functions to evaluate.</param>
            <returns>A sequence with results from invoking <paramref name="functions"/>.</returns>
            <exception cref="T:System.ArgumentNullException">When <paramref name="functions"/> is <c>null</c>.</exception>
        </member>
        <member name="T:MoreLinq.Extensions.ExactlyExtension">
            <summary><c>Exactly</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.ExactlyExtension.Exactly``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Determines whether or not the number of elements in the sequence is equals to the given integer.
            </summary>
            <typeparam name="T">Element type of sequence</typeparam>
            <param name="source">The source sequence</param>
            <param name="count">The exactly number of items a sequence must have for this
            function to return true</param>
            <exception cref="T:System.ArgumentNullException"><paramref name="source"/> is null</exception>
            <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="count"/> is negative</exception>
            <returns><c>true</c> if the number of elements in the sequence is equals
            to the given integer or <c>false</c> otherwise.</returns>
            <example>
            <code><![CDATA[
            var numbers = new[] { 123, 456, 789 };
            var result = numbers.Exactly(3);
            ]]></code>
            The <c>result</c> variable will contain <c>true</c>.
            </example>
        </member>
        <member name="T:MoreLinq.Extensions.ExceptByExtension">
            <summary><c>ExceptBy</c> extension.</summary>
        </member>
        <member name="M:MoreLinq.Extensions.ExceptByExtension.ExceptBy``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Returns the set of elements in the first sequence which aren't
            in the second sequence, according to a given key selector.
            </summary>
            <remarks>
            This is a set operation; if multiple elements in <paramref name="first"/> have