<?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"/>. The actual methods
            are implemented in files reflecting the method name.
            </summary>
        </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>
        </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>
        </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>
        </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>
        </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>{ 1, 2, 3, 4, 5 }</code> and with a predicate of
            <code>x =&gt; x == 3</code>, the result would be <code>{ 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.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.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 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.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"/>
            object and in source order.
            </returns>
            <remarks>
            This operator executes immediately.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Concat``1(``0,System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Returns a sequence consisting of the head element and the given tail elements.
            </summary>
            <typeparam name="T">Type of sequence</typeparam>
            <param name="head">Head element of the new sequence.</param>
            <param name="tail">All elements of the tail. Must not be null.</param>
            <returns>A sequence consisting of the head elements and the given tail elements.</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.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.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.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.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>
            int[] numbers = { 12, 34, 56, 78 };
            IEnumerable&lt;int&gt; result = numbers.TakeLast(2);
            </code>
            The <c>result</c> variable, when iterated over, will yield 
            34, 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>{ 1, 2, 3, 4, 5 }</code> and with a predicate of
            <code>x =&gt; x == 3</code>, the result would be <code>{ 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.BuildOrBindSchema(System.Data.DataTable,System.Reflection.MemberInfo[])">
            <remarks>
            The resulting array may contain null entries and those represent
            columns for which there is no source member supplying a value.
            </remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1,System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
            <summary>
            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/> 
            object with a set of lambda expressions specifying which members (property
            or field) of each element in the sequence will supply the column values.
            </summary>
            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
            <typeparam name="TTable">The type of the input and resulting <see cref="T:System.Data.DataTable"/> object.</typeparam>
            <param name="source">The source.</param>
            <param name="table">The <see cref="T:System.Data.DataTable"/> type of object where to add rows</param>
            <param name="expressions">Expressions providing access to element members.</param>
            <returns>
            A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
            </returns>
            <remarks>This operator uses immediate execution.</remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1)">
            <summary>
            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/> object.
            </summary>
            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
            <typeparam name="TTable"></typeparam>
            <param name="source">The source.</param>
            <param name="table"></param>
            <returns>
            A <see cref="T:System.Data.DataTable"/> or subclass representing the source.
            </returns>
            <remarks>This operator uses immediate execution.</remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDataTable``1(System.Collections.Generic.IEnumerable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[])">
            <summary>
            Appends elements in the sequence as rows of a given <see cref="T:System.Data.DataTable"/> 
            object with a set of lambda expressions specifying which members (property
            or field) of each element in the sequence will supply the column values.
            </summary>
            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The source.</param>
            <param name="expressions">Expressions providing access to element members.</param>
            <returns>
            A <see cref="T:System.Data.DataTable"/> representing the source.
            </returns>
            <remarks>This operator uses immediate execution.</remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDataTable``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Converts a sequence to a <see cref="T:System.Data.DataTable"/> object.
            </summary>
            <typeparam name="T">The type of the elements of <paramref name="source"/>.</typeparam>
            <param name="source">The source.</param>
            <returns>
            A <see cref="T:System.Data.DataTable"/> representing the source.
            </returns>
            <remarks>This operator uses immediate execution.</remarks>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.String})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Boolean})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.SByte})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Byte})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Char})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Int16})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Int32})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Int64})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Single})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Double})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.Decimal})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.UInt16})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.UInt32})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString(System.Collections.Generic.IEnumerable{System.UInt64})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <param name="source">The sequence of items to delimit. Each is converted to a string using the
            simple ToString() conversion.</param>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </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>
            <remarks>
            This evaluates the input sequence completely.
            </remarks>
            <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>
        </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>
            <remarks>
            This evaluates the input sequence completely.
            </remarks>
            <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>
        </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.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>
            <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>
            <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})">
            <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.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 eqaulity 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.GenerateByIndex``1(System.Func{System.Int32,``0})">
            <summary>
            Returns a sequence of values based on indexes.
            </summary>
            <remarks>
            The sequence is (practically) infinite
            - the index ranges from 0 to <c>int.MaxValue</c> inclusive. This function defers
            execution and streams the results.
            </remarks>
            <typeparam name="TResult">Type of result to generate</typeparam>
            <param name="generator">Generation function to apply to each index</param>
            <returns>A sequence </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>
            <remarks>
            This function defers element generation until needed and streams the results.
            </remarks>
            <example>
            <code>
            IEnumerable&lt;int&gt; result = Sequence.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.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.TakeEvery``1(System.Collections.Generic.IEnumerable{``0},System.Int32)">
            <summary>
            Returns every N-th element of a source 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>
            <remarks>
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code>
            int[] numbers = { 1, 2, 3, 4, 5 };
            IEnumerable&lt;int&gt; 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.Zip``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.
            </summary>
            <remarks>
            If the two input sequences are of different lengths, the result sequence 
            is terminated as soon as the shortest input sequence is exhausted.
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code>
            int[] numbers = { 1, 2, 3 };
            string[] letters = { "A", "B", "C", "D" };
            var zipped = numbers.Zip(letters, (n, l) => n + l);
            </code>
            The <c>zipped</c> variable, when iterated over, will yield "1A", "2B", "3C", in turn.
            </example>
            <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">First sequence</param>
            <param name="second">Second sequence</param>
            <param name="resultSelector">Function to apply to each pair of elements</param>
        </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.
            </summary>
            <remarks>
            If the two input sequences are of different lengths then 
            <see cref="T:System.InvalidOperationException"/> is thrown.
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code>
            int[] numbers = { 1, 2, 3, 4 };
            string[] letters = { "A", "B", "C", "D" };
            var zipped = numbers.EquiZip(letters, (n, l) =&gt; n + l);
            </code>
            The <c>zipped</c> variable, when iterated over, will yield "1A", "2B", "3C", "4D" in turn.
            </example>
            <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">First sequence</param>
            <param name="second">Second sequence</param>
            <param name="resultSelector">Function to apply to each pair of elements</param>
        </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.
            </summary>
            <remarks>
            If the two input sequences are of different lengths then the result 
            sequence will always be as long as the longer of the two input sequences.
            The default value of the shorter sequence element type is used for padding.
            This operator uses deferred execution and streams its results.
            </remarks>
            <example>
            <code>
            int[] numbers = { 1, 2, 3 };
            string[] letters = { "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", "0D" in turn.
            </example>
            <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">First sequence</param>
            <param name="second">Second sequence</param>
            <param name="resultSelector">Function to apply to each pair of elements</param>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Scan``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,``0})">
            <summary>
            Peforms a scan (inclusive prefix sum) on a sequence of elements.
            </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>
            Func&lt;int, int, int&gt; plus = (a, b) =&gt; a + b;
            int[] values = { 1, 2, 3, 4 };
            IEnumerable&lt;int&gt; prescan = values.PreScan(plus, 0);
            IEnumerable&lt;int&gt; scan = values.Scan(plus; a + b);
            IEnumerable&lt;int&gt; result = values.Zip(prescan, plus);
            </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>
            <exception cref="T:System.InvalidOperationException">If <paramref name="source"/> is empty.</exception>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},``0)">
            <summary>
            Splits the source sequence by a separator.
            </summary>
        </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>
        </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>
        </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>
        </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>
        </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>
        </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>
        </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>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.Split``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Boolean})">
            <summary>
            Splits the source sequence by a separator function.
            </summary>
        </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 a separator function, given a
            maximum count of splits.
            </summary>
        </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 a separator function and then
            transforms the splits into results.
            </summary>
        </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 a separator function, given a 
            maximum count of splits, and then transforms the splits into results.
            </summary>
        </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>
            Func&lt;int, int, int&gt; plus = (a, b) =&gt; a + b;
            int[] values = { 1, 2, 3, 4 };
            IEnumerable&lt;int&gt; prescan = values.PreScan(plus, 0);
            IEnumerable&lt;int&gt; scan = values.Scan(plus; a + b);
            IEnumerable&lt;int&gt; result = values.Zip(prescan, plus);
            </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.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>
            int[] numbers = { 123, 456, 789 };
            IEnumerable&lt;int&gt; result = numbers.Pairwise(5, (a, b) => a + b);
            </code>
            The <c>result</c> variable, when iterated over, will yield 
            579 and 1245, in turn.
            </example>
        </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>
            int[] numbers = { 123, 456, 789 };
            IEnumerable&lt;int&gt; 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>
            int[] numbers = { 123, 456, 789 };
            IEnumerable&lt;int&gt; 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>
            int[] numbers = { 0, 1, 2 };
            IEnumerable&lt;int&gt; 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.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>
            int[] numbers = { 1, 2, 3 };
            IEnumerable&lt;int&gt; 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.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Returns the minimal element of the given sequence, based on
            the given projection.
            </summary>
            <remarks>
            If more than one element has the minimal projected value, the first
            one encountered will be returned. This overload uses the default comparer
            for the projected type. This operator uses immediate execution, but
            only buffers a single result (the current minimal element).
            </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 element of the given sequence, based on
            the given projection and the specified comparer for projected values.
            </summary>
            <remarks>
            If more than one element has the minimal projected value, the first
            one encountered will be returned. This overload uses the default comparer
            for the projected type. This operator uses immediate execution, but
            only buffers a single result (the current minimal element).
            </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.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
            <summary>
            Returns the maximal element of the given sequence, based on
            the given projection.
            </summary>
            <remarks>
            If more than one element has the maximal projected value, the first
            one encountered will be returned. This overload uses the default comparer
            for the projected type. This operator uses immediate execution, but
            only buffers a single result (the current maximal element).
            </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 element of the given sequence, based on
            the given projection and the specified comparer for projected values. 
            </summary>
            <remarks>
            If more than one element has the maximal projected value, the first
            one encountered will be returned. This overload uses the default comparer
            for the projected type. This operator uses immediate execution, but
            only buffers a single result (the current maximal element).
            </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.SingleOrFallback``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0})">
            <summary>
            Returns the single element in the given sequence, or the result
            of executing a fallback delegate if the sequence is empty.
            This method throws an exception if there is more than one element in the sequence.
            </summary>
            <remarks>
            The fallback delegate is not executed if the sequence is non-empty.
            This operator uses immediate execution and has optimizations for <see cref="T:System.Collections.Generic.IList`1"/> sources.
            </remarks>
            <typeparam name="TSource">Element type of sequence</typeparam>
            <param name="source">The source sequence</param>
            <param name="fallback">The fallback delegate to execute if the sequence is empty</param>
            <exception cref="T:System.ArgumentNullException">source or fallback is null</exception>
            <exception cref="T:System.InvalidOperationException">The sequence has more than one element</exception>
            <returns>The single element in the sequence, or the result of calling the
            fallback delegate if the sequence is empty.</returns>
        </member>
        <member name="M:MoreLinq.MoreEnumerable.ToDelimitedString``1(System.Collections.Generic.IEnumerable{``0})">
            <summary>
            Creates a delimited string from a sequence of values. The 
            delimiter used depends on the current culture of the executing thread.
            </summary>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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>
        </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>
            <remarks>
            This operator uses immediate execution and effectively buffers the sequence.
            </remarks>
            <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. May be null, in which case
            the executing thread's current culture's list separator is used.</param>
        </member>
        <member name="T:MoreLinq.SequenceException">
            <summary>
            The exception that is thrown for a sequence that fails a condition.
            </summary>
        </member>
        <member name="M:MoreLinq.SequenceException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class. 
            </summary>
        </member>
        <member name="M:MoreLinq.SequenceException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class
            with a given error message. 
            </summary>
            <param name="message">A message that describes the error.</param>
        </member>
        <member name="M:MoreLinq.SequenceException.#ctor(System.String,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class
            with a given error message and a reference to the inner exception
            that is the cause of the exception.
            </summary>
            <param name="message">A message that describes the error.</param>
            <param name="innerException">The exception that is the cause of the current exception.</param>
        </member>
        <member name="M:MoreLinq.SequenceException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Initializes a new instance of the <see cref="T:MoreLinq.SequenceException"/> class
            with serialized data.
            </summary>
            <param name="info">The object that holds the serialized object data.</param>
            <param name="context">The contextual information about the source or destination.</param>
        </member>
    </members>
</doc>
