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) => $"({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) => $"({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) => $"({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>
            <para>
            This operator uses deferred execution and streams its results
            (buckets are streamed but their content buffered).</para>
            <para>
            When more than one bucket is streamed, all buckets except the last
            is guaranteed to have <paramref name="size"/> elements. The last
            bucket may be smaller depending on the remaining elements in the
            <paramref name="source"/> sequence.</para>
            <para>
            Each bucket is pre-allocated to <paramref name="size"/> elements.
            If <paramref name="size"/> is set to a very large value, e.g.
            <see cref="F:System.Int32.MaxValue"/> to effectively disable batching by just
            hoping for a single bucket, then it can lead to memory exhaustion
            (<see cref="T:System.OutOfMemoryException"/>).
            </para>
            </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>
            <para>
            This operator uses deferred execution and streams its results
            (buckets are streamed but their content buffered).</para>
            <para>
            <para>
            When more than one bucket is streamed, all buckets except the last
            is guaranteed to have <paramref name="size"/> elements. The last
            bucket may be smaller depending on the remaining elements in the
            <paramref name="source"/> sequence.</para>
            Each bucket is pre-allocated to <paramref name="size"/> elements.
            If <paramref name="size"/> is set to a very large value, e.g.
            <see cref="F:System.Int32.MaxValue"/> to effectively disable batching by just
            hoping for a single bucket, then it can lead to memory exhaustion
            (<see cref="T:System.OutOfMemoryException"/>).
            </para>
            </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 countdown 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 maximum 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 maximum 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>