| AggregateAsync<TSource,TAccumulate,TResult>(IAsyncEnumerable<TSource>,
 TAccumulate, Func<TAccumulate,TSource,CancellationToken,ValueTask<TAccumulate>>,
 Func<TAccumulate,CancellationToken,ValueTask<TResult>>, CancellationToken) | Applies an 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. | 
        	
	| AggregateAsync<TSource,TAccumulate,TResult>(IAsyncEnumerable<TSource>,
 TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,
TResult>, CancellationToken) | Applies an 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. | 
        	
	| AggregateAsync<TSource,TAccumulate>(IAsyncEnumerable<TSource>,
 TAccumulate, Func<TAccumulate,TSource,CancellationToken,ValueTask<TAccumulate>>,
 CancellationToken) | Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value. | 
        	
	| AggregateAsync<TSource,TAccumulate>(IAsyncEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, CancellationToken) | Applies an accumulator function over a sequence. The specified seed value is used as the initial accumulator value. | 
        	
	| AggregateAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,TSource,CancellationToken,ValueTask<TSource>>, CancellationToken) | Applies an accumulator function over a sequence. | 
        	
	| AggregateAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,TSource,TSource>, CancellationToken) | Applies an accumulator function over a sequence. | 
        	
	| AggregateBy<TSource,TKey,TAccumulate>(IAsyncEnumerable<TSource>,
 Func<TSource,CancellationToken,ValueTask<TKey>>, Func<TKey,CancellationToken,
ValueTask<TAccumulate>>, Func<TAccumulate,TSource,CancellationToken,
ValueTask<TAccumulate>>, IEqualityComparer<TKey>) | Applies an accumulator function over a sequence, grouping results by key. | 
        	
	| AggregateBy<TSource,TKey,TAccumulate>(IAsyncEnumerable<TSource>,
 Func<TSource,CancellationToken,ValueTask<TKey>>, TAccumulate,
 Func<TAccumulate,TSource,CancellationToken,ValueTask<TAccumulate>>,
 IEqualityComparer<TKey>) | Applies an accumulator function over a sequence, grouping results by key. | 
        	
	| AggregateBy<TSource,TKey,TAccumulate>(IAsyncEnumerable<TSource>,
 Func<TSource,TKey>, Func<TKey,TAccumulate>, Func<TAccumulate,
TSource,TAccumulate>, IEqualityComparer<TKey>) | Applies an accumulator function over a sequence, grouping results by key. | 
        	
	| AggregateBy<TSource,TKey,TAccumulate>(IAsyncEnumerable<TSource>,
 Func<TSource,TKey>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>,
 IEqualityComparer<TKey>) | Applies an accumulator function over a sequence, grouping results by key. | 
        	
	| AllAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>, CancellationToken) | Determines whether all elements of a sequence satisfy a condition. | 
        	
	| AllAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>, CancellationToken) | Determines whether all elements of a sequence satisfy a condition. | 
        	
	| AnyAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken) | Determines whether a sequence contains any elements. | 
        	
	| AnyAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>, CancellationToken) | Determines whether any element of a sequence satisfies a condition. | 
        	
	| AnyAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>, CancellationToken) | Determines whether any element of a sequence satisfies a condition. | 
        	
	| Append<TSource>(IAsyncEnumerable<TSource>, TSource) | Appends a value to the end of the sequence. | 
        	
	| AverageAsync(IAsyncEnumerable<Decimal>, CancellationToken) | Computes the average of a sequence of values. | 
        	
	| AverageAsync(IAsyncEnumerable<Double>, CancellationToken) | Computes the average of a sequence of values. | 
        	
	| AverageAsync(IAsyncEnumerable<Int32>, CancellationToken) | Computes the average of a sequence of values. | 
        	
	| AverageAsync(IAsyncEnumerable<Int64>, CancellationToken) | Computes the average of a sequence of values. | 
        	
	| AverageAsync(IAsyncEnumerable<Nullable<Decimal>>, CancellationToken) | Computes the average of a sequence of nullable values. | 
        	
	| AverageAsync(IAsyncEnumerable<Nullable<Double>>, CancellationToken) | Computes the average of a sequence of nullable values. | 
        	
	| AverageAsync(IAsyncEnumerable<Nullable<Int32>>, CancellationToken) | Computes the average of a sequence of nullable values. | 
        	
	| AverageAsync(IAsyncEnumerable<Nullable<Int64>>, CancellationToken) | Computes the average of a sequence of nullable values. | 
        	
	| AverageAsync(IAsyncEnumerable<Nullable<Single>>, CancellationToken) | Computes the average of a sequence of nullable values. | 
        	
	| AverageAsync(IAsyncEnumerable<Single>, CancellationToken) | Computes the average of a sequence of values. | 
        	
	| Cast<TResult>(IAsyncEnumerable<Object>) | Casts the elements of an IAsyncEnumerable<T> to the specified type. | 
        	
	| Chunk<TSource>(IAsyncEnumerable<TSource>, Int32) | Split the elements of a sequence into chunks of size at most size. | 
        	
	| Concat<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>) | Concatenates two sequences. | 
        	
	| ContainsAsync<TSource>(IAsyncEnumerable<TSource>, TSource, IEqualityComparer<TSource>, CancellationToken) | Determines whether a sequence contains a specified element. | 
        	
	| CountAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken) | Returns the number of elements in a sequence. | 
        	
	| CountAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>, CancellationToken) | Returns the number of elements in a sequence satisfy a condition. | 
        	
	| CountAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>, CancellationToken) | Returns the number of elements in a sequence satisfy a condition. | 
        	
	| CountBy<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<TKey>>, IEqualityComparer<TKey>) | Returns the count of elements in the source sequence grouped by key. | 
        	
	| CountBy<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) | Returns the count of elements in the source sequence grouped by key. | 
        	
	| DefaultIfEmpty<TSource>(IAsyncEnumerable<TSource>, TSource) | Returns the elements of the specified sequence or the specified value if the sequence is empty. | 
        	
	| DefaultIfEmpty<TSource>(IAsyncEnumerable<TSource>) | Returns the elements of the specified sequence or the type parameter's default if the sequence is empty. | 
        	
	| Distinct<TSource>(IAsyncEnumerable<TSource>, IEqualityComparer<TSource>) | Returns distinct elements from a sequence. | 
        	
	| DistinctBy<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<TKey>>, IEqualityComparer<TKey>) | Returns distinct elements from a sequence according to a specified key selector function. | 
        	
	| DistinctBy<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) | Returns distinct elements from a sequence according to a specified key selector function. | 
        	
	| ElementAtAsync<TSource>(IAsyncEnumerable<TSource>, Index, CancellationToken) | Returns the element at a specified index in a sequence. | 
        	
	| ElementAtAsync<TSource>(IAsyncEnumerable<TSource>, Int32, CancellationToken) | Returns the element at a specified index in a sequence. | 
        	
	| ElementAtOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Index, CancellationToken) | Returns the element at a specified index in a sequence or a default value if the index is out of range. | 
        	
	| ElementAtOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Int32, CancellationToken) | Returns the element at a specified index in a sequence, or a default value if the index is out of range. | 
        	
	| Empty<TResult>() | Returns an empty IAsyncEnumerable<T> that has the specified type argument. | 
        	
	| Except<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, IEqualityComparer<TSource>) | Produces the set difference of two sequences. | 
        	
	| ExceptBy<TSource,TKey>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TKey>, Func<TSource,CancellationToken,ValueTask<TKey>>, IEqualityComparer<TKey>) | Produces the set difference of two sequences according to a specified key selector function. | 
        	
	| ExceptBy<TSource,TKey>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>) | Produces the set difference of two sequences according to a specified key selector function. | 
        	
	| FirstAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken) | Returns the first element of a sequence. | 
        	
	| FirstAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>, CancellationToken) | Returns the first element in a sequence that satisfies a specified condition. | 
        	
	| FirstAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>, CancellationToken) | Returns the first element in a sequence that satisfies a specified condition. | 
        	
	| FirstOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken) | Returns the first element of a sequence, or the default value of TSourceif the sequence contains no elements. | 
        	
	| FirstOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>, CancellationToken) | Returns the first element of the sequence that satisfies a condition or a default value if no such element is found. | 
        	
	| FirstOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>, TSource, CancellationToken) | Returns the first element of the sequence that satisfies a condition or a default value if no such element is found. | 
        	
	| FirstOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>, CancellationToken) | Returns the first element of the sequence that satisfies a condition or a default value if no such element is found. | 
        	
	| FirstOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>, TSource, CancellationToken) | Returns the first element of the sequence that satisfies a condition or a default value if no such element is found. | 
        	
	| FirstOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, TSource, CancellationToken) | Returns the first element of a sequence, or a default value if the sequence contains no elements. | 
        	
	| GroupBy<TSource,TKey,TElement,TResult>(IAsyncEnumerable<TSource>,
 Func<TSource,CancellationToken,ValueTask<TKey>>, Func<TSource,
CancellationToken,ValueTask<TElement>>, Func<TKey,IEnumerable<TElement>,
CancellationToken,ValueTask<TResult>>, IEqualityComparer<TKey>) | Groups the elements of a sequence according to a specified key selector function
and creates a result value from each group and its key. Key values are compared
by using a specified comparer, and the elements of each group are projected by
using a specified function. | 
        	
	| GroupBy<TSource,TKey,TElement,TResult>(IAsyncEnumerable<TSource>,
 Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,
TResult>, IEqualityComparer<TKey>) | Groups the elements of a sequence according to a specified key selector function
and creates a result value from each group and its key. Key values are compared
by using a specified comparer, and the elements of each group are projected by
using a specified function. | 
        	
	| GroupBy<TSource,TKey,TElement>(IAsyncEnumerable<TSource>, Func<TSource,
CancellationToken,ValueTask<TKey>>, Func<TSource,CancellationToken,
ValueTask<TElement>>, IEqualityComparer<TKey>) | Groups the elements of a sequence according to a key selector function. The keys
are compared by using a comparer and each group's elements are projected by using
a specified function. | 
        	
	| GroupBy<TSource,TKey,TElement>(IAsyncEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) | Groups the elements of a sequence according to a key selector function. The keys
are compared by using a comparer and each group's elements are projected by using
a specified function. | 
        	
	| GroupBy<TSource,TKey,TResult>(IAsyncEnumerable<TSource>, Func<TSource,
CancellationToken,ValueTask<TKey>>, Func<TKey,IEnumerable<TSource>,
CancellationToken,ValueTask<TResult>>, IEqualityComparer<TKey>) | Groups the elements of a sequence according to a specified key selector function
and creates a result value from each group and its key. | 
        	
	| GroupBy<TSource,TKey,TResult>(IAsyncEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>) | Groups the elements of a sequence according to a specified key selector function
and creates a result value from each group and its key. | 
        	
	| GroupBy<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<TKey>>, IEqualityComparer<TKey>) | Groups the elements of a sequence according to a specified key selector function. | 
        	
	| GroupBy<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) | Groups the elements of a sequence according to a specified key selector function. | 
        	
	| GroupJoin<TOuter,TInner,TKey,TResult>(IAsyncEnumerable<TOuter>,
 IAsyncEnumerable<TInner>, Func<TOuter,CancellationToken,ValueTask<TKey>>,
 Func<TInner,CancellationToken,ValueTask<TKey>>, Func<TOuter,
IEnumerable<TInner>,CancellationToken,ValueTask<TResult>>, IEqualityComparer<TKey>) | Correlates the elements of two sequences based on key equality and groups the results. | 
        	
	| GroupJoin<TOuter,TInner,TKey,TResult>(IAsyncEnumerable<TOuter>,
 IAsyncEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>,
 Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>) | Correlates the elements of two sequences based on key equality and groups the results. | 
        	
	| Index<TSource>(IAsyncEnumerable<TSource>) | Returns an enumerable that incorporates the element's index into a tuple. | 
        	
	| InfiniteSequence<T>(T, T) | Generates an infinite sequence that begins with startand yields additional values each incremented bystep. | 
        	
	| Intersect<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, IEqualityComparer<TSource>) | Produces the set intersection of two sequences. | 
        	
	| IntersectBy<TSource,TKey>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TKey>,
 Func<TSource,CancellationToken,ValueTask<TKey>>, IEqualityComparer<TKey>) | Produces the set intersection of two sequences according to a specified key selector function. | 
        	
	| IntersectBy<TSource,TKey>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>) | Produces the set intersection of two sequences according to a specified key selector function. | 
        	
	| Join<TOuter,TInner,TKey,TResult>(IAsyncEnumerable<TOuter>, IAsyncEnumerable<TInner>,
 Func<TOuter,CancellationToken,ValueTask<TKey>>, Func<TInner,
CancellationToken,ValueTask<TKey>>, Func<TOuter,TInner,CancellationToken,
ValueTask<TResult>>, IEqualityComparer<TKey>) | Correlates the elements of two sequences based on matching keys. | 
        	
	| Join<TOuter,TInner,TKey,TResult>(IAsyncEnumerable<TOuter>, IAsyncEnumerable<TInner>,
 Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>,
 IEqualityComparer<TKey>) | Correlates the elements of two sequences based on matching keys. | 
        	
	| LastAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken) | Returns the last element of a sequence. | 
        	
	| LastAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>, CancellationToken) | Returns the last element of a sequence that satisfies a specified condition. | 
        	
	| LastAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>, CancellationToken) | Returns the last element of a sequence that satisfies a specified condition. | 
        	
	| LastOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken) | Returns the last element of a sequence, or a default value if the sequence contains no elements. | 
        	
	| LastOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>, CancellationToken) | Returns the last element of a sequence that satisfies a condition or a default value if no such element is found. | 
        	
	| LastOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>, TSource, CancellationToken) | Returns the last element of a sequence that satisfies a condition or a default value if no such element is found. | 
        	
	| LastOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>, CancellationToken) | Returns the last element of a sequence that satisfies a condition or a default value if no such element is found. | 
        	
	| LastOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>, TSource, CancellationToken) | Returns the last element of a sequence that satisfies a condition or a default value if no such element is found. | 
        	
	| LastOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, TSource, CancellationToken) | Returns the last element of a sequence, or a default value if the sequence contains no elements. | 
        	
	| LeftJoin<TOuter,TInner,TKey,TResult>(IAsyncEnumerable<TOuter>,
 IAsyncEnumerable<TInner>, Func<TOuter,CancellationToken,ValueTask<TKey>>,
 Func<TInner,CancellationToken,ValueTask<TKey>>, Func<TOuter,
TInner,CancellationToken,ValueTask<TResult>>, IEqualityComparer<TKey>) | Correlates the elements of two sequences based on matching keys. | 
        	
	| LeftJoin<TOuter,TInner,TKey,TResult>(IAsyncEnumerable<TOuter>,
 IAsyncEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>,
 Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>) | Correlates the elements of two sequences based on matching keys. | 
        	
	| LongCountAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken) | Returns the number of elements in a sequence satisfy a condition. | 
        	
	| LongCountAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>, CancellationToken) | Returns the number of elements in a sequence satisfy a condition. | 
        	
	| LongCountAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>, CancellationToken) | Returns the number of elements in a sequence satisfy a condition. | 
        	
	| MaxAsync<TSource>(IAsyncEnumerable<TSource>, IComparer<TSource>, CancellationToken) | Returns the maximum value in a generic sequence. | 
        	
	| MaxByAsync<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<TKey>>, IComparer<TKey>, CancellationToken) | Returns the maximum value in a generic sequence according to a specified key selector function. | 
        	
	| MaxByAsync<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>, CancellationToken) | Returns the maximum value in a generic sequence according to a specified key selector function. | 
        	
	| MinAsync<TSource>(IAsyncEnumerable<TSource>, IComparer<TSource>, CancellationToken) | Returns the minimum value in a generic sequence. | 
        	
	| MinByAsync<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<TKey>>, IComparer<TKey>, CancellationToken) | Returns the minimum value in a generic sequence according to a specified key selector function. | 
        	
	| MinByAsync<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>, CancellationToken) | Returns the minimum value in a generic sequence according to a specified key selector function. | 
        	
	| OfType<TResult>(IAsyncEnumerable<Object>) | Filters the elements of a IAsyncEnumerable<T> based on a specified type TResult. | 
        	
	| Order<T>(IAsyncEnumerable<T>, IComparer<T>) | Sorts the elements of a sequence in ascending order. | 
        	
	| OrderBy<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<TKey>>, IComparer<TKey>) | Sorts the elements of a sequence in ascending order. | 
        	
	| OrderBy<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) | Sorts the elements of a sequence in ascending order. | 
        	
	| OrderByDescending<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<TKey>>, IComparer<TKey>) | Sorts the elements of a sequence in descending order. | 
        	
	| OrderByDescending<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) | Sorts the elements of a sequence in descending order. | 
        	
	| OrderDescending<T>(IAsyncEnumerable<T>, IComparer<T>) | Sorts the elements of a sequence in descending order. | 
        	
	| Prepend<TSource>(IAsyncEnumerable<TSource>, TSource) | Adds a value to the beginning of the sequence. | 
        	
	| Range(Int32, Int32) | Generates a sequence of integral numbers within a specified range. | 
        	
	| Repeat<TResult>(TResult, Int32) | Generates a sequence that contains one repeated value. | 
        	
	| Reverse<TSource>(IAsyncEnumerable<TSource>) | Inverts the order of the elements in a sequence. | 
        	
	| RightJoin<TOuter,TInner,TKey,TResult>(IAsyncEnumerable<TOuter>,
 IAsyncEnumerable<TInner>, Func<TOuter,CancellationToken,ValueTask<TKey>>,
 Func<TInner,CancellationToken,ValueTask<TKey>>, Func<TOuter,
TInner,CancellationToken,ValueTask<TResult>>, IEqualityComparer<TKey>) | Correlates the elements of two sequences based on matching keys. | 
        	
	| RightJoin<TOuter,TInner,TKey,TResult>(IAsyncEnumerable<TOuter>,
 IAsyncEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>,
 Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>) | Correlates the elements of two sequences based on matching keys. | 
        	
	| Select<TSource,TResult>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<TResult>>) | Projects each element of a sequence into a new form. | 
        	
	| Select<TSource,TResult>(IAsyncEnumerable<TSource>, Func<TSource,Int32,CancellationToken,ValueTask<TResult>>) | Projects each element of a sequence into a new form by incorporating the element's index. | 
        	
	| Select<TSource,TResult>(IAsyncEnumerable<TSource>, Func<TSource,Int32,TResult>) | Projects each element of a sequence into a new form by incorporating the element's index. | 
        	
	| Select<TSource,TResult>(IAsyncEnumerable<TSource>, Func<TSource,TResult>) | Projects each element of a sequence into a new form. | 
        	
	| SelectMany<TSource,TCollection,TResult>(IAsyncEnumerable<TSource>,
 Func<TSource,CancellationToken,ValueTask<IEnumerable<TCollection>>>,
 Func<TSource,TCollection,CancellationToken,ValueTask<TResult>>) | Projects each element of a sequence to an IEnumerable<T>,
flattens the resulting sequences into one IAsyncEnumerable<T> sequence,
and invokes a result selector function on each element therein. The index of each source element is used in
the intermediate projected form of that element. | 
        	
	| SelectMany<TSource,TCollection,TResult>(IAsyncEnumerable<TSource>,
 Func<TSource,IAsyncEnumerable<TCollection>>, Func<TSource,TCollection,
CancellationToken,ValueTask<TResult>>) | Projects each element of a sequence to an IAsyncEnumerable<T>,
flattens the resulting sequences into one IAsyncEnumerable<T> sequence,
and invokes a result selector function on each element therein. The index of each source element is used in
the intermediate projected form of that element. | 
        	
	| SelectMany<TSource,TCollection,TResult>(IAsyncEnumerable<TSource>, Func<TSource,IAsyncEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) | Projects each element of a sequence to an IAsyncEnumerable<T>,
flattens the resulting sequences into one IAsyncEnumerable<T> sequence,
and invokes a result selector function on each element therein. The index of each source element is used in
the intermediate projected form of that element. | 
        	
	| SelectMany<TSource,TCollection,TResult>(IAsyncEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) | Projects each element of a sequence to an IEnumerable<T>,
flattens the resulting sequences into one IAsyncEnumerable<T> sequence,
and invokes a result selector function on each element therein. The index of each source element is used in
the intermediate projected form of that element. | 
        	
	| SelectMany<TSource,TCollection,TResult>(IAsyncEnumerable<TSource>,
 Func<TSource,Int32,CancellationToken,ValueTask<IEnumerable<TCollection>>>,
 Func<TSource,TCollection,CancellationToken,ValueTask<TResult>>) | Projects each element of a sequence to an IEnumerable<T>,
flattens the resulting sequences into one IAsyncEnumerable<T> sequence,
and invokes a result selector function on each element therein. | 
        	
	| SelectMany<TSource,TCollection,TResult>(IAsyncEnumerable<TSource>,
 Func<TSource,Int32,IAsyncEnumerable<TCollection>>, Func<TSource,
TCollection,CancellationToken,ValueTask<TResult>>) | Projects each element of a sequence to an IAsyncEnumerable<T>,
flattens the resulting sequences into one IAsyncEnumerable<T> sequence,
and invokes a result selector function on each element therein. | 
        	
	| SelectMany<TSource,TCollection,TResult>(IAsyncEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) | Projects each element of a sequence to an IEnumerable<T>,
flattens the resulting sequences into one IAsyncEnumerable<T> sequence,
and invokes a result selector function on each element therein. | 
        	
	| SelectMany<TSource,TResult>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<IEnumerable<TResult>>>) | Projects each element of a sequence to an IEnumerable<T> and
flattens the resulting sequences into one IAsyncEnumerable<T> sequence. | 
        	
	| SelectMany<TSource,TResult>(IAsyncEnumerable<TSource>, Func<TSource,IAsyncEnumerable<TResult>>) | Projects each element of a sequence to an IAsyncEnumerable<T> and
flattens the resulting sequences into one IAsyncEnumerable<T> sequence. | 
        	
	| SelectMany<TSource,TResult>(IAsyncEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) | Projects each element of a sequence to an IEnumerable<T> and
flattens the resulting sequences into one IAsyncEnumerable<T> sequence. | 
        	
	| SelectMany<TSource,TResult>(IAsyncEnumerable<TSource>, Func<TSource,Int32,CancellationToken,ValueTask<IEnumerable<TResult>>>) | Projects each element of a sequence to an IEnumerable<T> and
flattens the resulting sequences into one IAsyncEnumerable<T> sequence.
The index of each source element is used in the projected form of that element. | 
        	
	| SelectMany<TSource,TResult>(IAsyncEnumerable<TSource>, Func<TSource,Int32,IAsyncEnumerable<TResult>>) | Projects each element of a sequence to an IAsyncEnumerable<T> and
flattens the resulting sequences into one IAsyncEnumerable<T> sequence.
The index of each source element is used in the projected form of that element. | 
        	
	| SelectMany<TSource,TResult>(IAsyncEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) | Projects each element of a sequence to an IEnumerable<T> and
flattens the resulting sequences into one IAsyncEnumerable<T> sequence.
The index of each source element is used in the projected form of that element. | 
        	
	| Sequence<T>(T, T, T) | Generates a sequence that begins with startand yields additional values each incremented bystepuntilendInclusiveis reached. | 
        	
	| SequenceEqualAsync<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, IEqualityComparer<TSource>, CancellationToken) | Determines whether two sequences are equal by comparing their elements. | 
        	
	| Shuffle<TSource>(IAsyncEnumerable<TSource>) | Shuffles the order of the elements of a sequence. | 
        	
	| SingleAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken) | Returns the only element of a sequence, and throws an exception if there is not
exactly one element in the sequence. | 
        	
	| SingleAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>, CancellationToken) | Returns the only element of a sequence that satisfies a specified condition,
and throws an exception if more than one such element exists. | 
        	
	| SingleAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>, CancellationToken) | Returns the only element of a sequence that satisfies a specified condition,
and throws an exception if more than one such element exists. | 
        	
	| SingleOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken) | Returns the only element of a sequence, or a default value if the sequence is
empty; this method throws an exception if there is more than one element in the sequence. | 
        	
	| SingleOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>, CancellationToken) | Returns the only element of a sequence that satisfies a specified condition or
a default value if no such element exists; this method throws an exception if
more than one element satisfies the condition. | 
        	
	| SingleOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>, TSource, CancellationToken) | Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition. | 
        	
	| SingleOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>, CancellationToken) | Returns the only element of a sequence that satisfies a specified condition or
a default value if no such element exists; this method throws an exception if
more than one element satisfies the condition. | 
        	
	| SingleOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>, TSource, CancellationToken) | Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition. | 
        	
	| SingleOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, TSource, CancellationToken) | Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence. | 
        	
	| Skip<TSource>(IAsyncEnumerable<TSource>, Int32) | Bypasses a specified number of elements in a sequence and then returns the remaining elements. | 
        	
	| SkipLast<TSource>(IAsyncEnumerable<TSource>, Int32) | Returns a new sequence that contains the elements from sourcewith the lastcountelements of the source collection omitted. | 
        	
	| SkipWhile<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>) | Bypasses elements in a sequence as long as a specified condition is true and
then returns the remaining elements. | 
        	
	| SkipWhile<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>) | Bypasses elements in a sequence as long as a specified condition is true and
then returns the remaining elements. | 
        	
	| SkipWhile<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Int32,Boolean>) | Bypasses elements in a sequence as long as a specified condition is true and
then returns the remaining elements. The element's index is used in the logic
of the predicate function. | 
        	
	| SkipWhile<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Int32,CancellationToken,ValueTask<Boolean>>) | Bypasses elements in a sequence as long as a specified condition is true and
then returns the remaining elements. The element's index is used in the logic
of the predicate function. | 
        	
	| SumAsync(IAsyncEnumerable<Decimal>, CancellationToken) | Computes the sum of a sequence of values. | 
        	
	| SumAsync(IAsyncEnumerable<Double>, CancellationToken) | Computes the sum of a sequence of values. | 
        	
	| SumAsync(IAsyncEnumerable<Int32>, CancellationToken) | Computes the sum of a sequence of values. | 
        	
	| SumAsync(IAsyncEnumerable<Int64>, CancellationToken) | Computes the sum of a sequence of values. | 
        	
	| SumAsync(IAsyncEnumerable<Nullable<Decimal>>, CancellationToken) | Computes the sum of a sequence of nullable values. | 
        	
	| SumAsync(IAsyncEnumerable<Nullable<Double>>, CancellationToken) | Computes the sum of a sequence of nullable values. | 
        	
	| SumAsync(IAsyncEnumerable<Nullable<Int32>>, CancellationToken) | Computes the sum of a sequence of nullable values. | 
        	
	| SumAsync(IAsyncEnumerable<Nullable<Int64>>, CancellationToken) | Computes the sum of a sequence of nullable values. | 
        	
	| SumAsync(IAsyncEnumerable<Nullable<Single>>, CancellationToken) | Computes the sum of a sequence of nullable values. | 
        	
	| SumAsync(IAsyncEnumerable<Single>, CancellationToken) | Computes the sum of a sequence of values. | 
        	
	| Take<TSource>(IAsyncEnumerable<TSource>, Int32) | Returns a specified number of contiguous elements from the start of a sequence. | 
        	
	| Take<TSource>(IAsyncEnumerable<TSource>, Range) | Returns a specified range of contiguous elements from a sequence. | 
        	
	| TakeLast<TSource>(IAsyncEnumerable<TSource>, Int32) | Returns a new sequence that contains the last countelements fromsource. | 
        	
	| TakeWhile<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>) | Returns elements from a sequence as long as a specified condition is true. | 
        	
	| TakeWhile<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>) | Returns elements from a sequence as long as a specified condition is true. | 
        	
	| TakeWhile<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Int32,Boolean>) | Returns elements from a sequence as long as a specified condition is true.
The element's index is used in the logic of the predicate function. | 
        	
	| TakeWhile<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Int32,CancellationToken,ValueTask<Boolean>>) | Returns elements from a sequence as long as a specified condition is true.
The element's index is used in the logic of the predicate function. | 
        	
	| ThenBy<TSource,TKey>(IOrderedAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<TKey>>, IComparer<TKey>) | Performs a subsequent ordering of the elements in a sequence in ascending order. | 
        	
	| ThenBy<TSource,TKey>(IOrderedAsyncEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) | Performs a subsequent ordering of the elements in a sequence in ascending order. | 
        	
	| ThenByDescending<TSource,TKey>(IOrderedAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<TKey>>, IComparer<TKey>) | Performs a subsequent ordering of the elements in a sequence in descending order. | 
        	
	| ThenByDescending<TSource,TKey>(IOrderedAsyncEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) | Performs a subsequent ordering of the elements in a sequence in descending order. | 
        	
	| ToArrayAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken) | Creates an array from an IAsyncEnumerable<T>. | 
        	
	| ToAsyncEnumerable<TSource>(IEnumerable<TSource>) | Creates a new IAsyncEnumerable<T> that iterates through source. | 
        	
	| ToDictionaryAsync<TKey,TValue>(IAsyncEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>, CancellationToken) | Creates a Dictionary<TKey,TValue> from an IAsyncEnumerable<T> according to specified key comparer. | 
        	
	| ToDictionaryAsync<TKey,TValue>(IAsyncEnumerable<ValueTuple<TKey,TValue>>, IEqualityComparer<TKey>, CancellationToken) | Creates a Dictionary<TKey,TValue> from an IAsyncEnumerable<T> according to specified key comparer. | 
        	
	| ToDictionaryAsync<TSource,TKey,TElement>(IAsyncEnumerable<TSource>,
 Func<TSource,CancellationToken,ValueTask<TKey>>, Func<TSource,
CancellationToken,ValueTask<TElement>>, IEqualityComparer<TKey>,
 CancellationToken) | Creates a Dictionary<TKey,TValue> from an IAsyncEnumerable<T>"/>
according to specified key selector and element selector functions. | 
        	
	| ToDictionaryAsync<TSource,TKey,TElement>(IAsyncEnumerable<TSource>,
 Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>,
 CancellationToken) | Creates a Dictionary<TKey,TValue> from an IAsyncEnumerable<T>"/>
according to specified key selector and element selector functions. | 
        	
	| ToDictionaryAsync<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,
CancellationToken,ValueTask<TKey>>, IEqualityComparer<TKey>, CancellationToken) | Creates a Dictionary<TKey,TValue> from an IAsyncEnumerable<T>
according to a specified key selector function. | 
        	
	| ToDictionaryAsync<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>, CancellationToken) | Creates a Dictionary<TKey,TValue> from an IAsyncEnumerable<T>
according to a specified key selector function. | 
        	
	| ToHashSetAsync<TSource>(IAsyncEnumerable<TSource>, IEqualityComparer<TSource>, CancellationToken) | Creates a HashSet<T> from an IAsyncEnumerable<T>. | 
        	
	| ToListAsync<TSource>(IAsyncEnumerable<TSource>, CancellationToken) | Creates a list from an IAsyncEnumerable<T>. | 
        	
	| ToLookupAsync<TSource,TKey,TElement>(IAsyncEnumerable<TSource>,
 Func<TSource,CancellationToken,ValueTask<TKey>>, Func<TSource,
CancellationToken,ValueTask<TElement>>, IEqualityComparer<TKey>,
 CancellationToken) | Creates a ILookup<TKey,TElement> from an IAsyncEnumerable<T>
according to a specified key selector function and element selector functions. | 
        	
	| ToLookupAsync<TSource,TKey,TElement>(IAsyncEnumerable<TSource>,
 Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>,
 CancellationToken) | Creates a ILookup<TKey,TElement> from an IAsyncEnumerable<T>
according to a specified key selector function and element selector functions. | 
        	
	| ToLookupAsync<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<TKey>>, IEqualityComparer<TKey>, CancellationToken) | Creates a ILookup<TKey,TElement> from an IAsyncEnumerable<T>
according to a specified key selector function. | 
        	
	| ToLookupAsync<TSource,TKey>(IAsyncEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>, CancellationToken) | Creates a ILookup<TKey,TElement> from an IAsyncEnumerable<T>
according to a specified key selector function. | 
        	
	| Union<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, IEqualityComparer<TSource>) | Produces the set union of two sequences. | 
        	
	| UnionBy<TSource,TKey>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<TKey>>, IEqualityComparer<TKey>) | Produces the set union of two sequences according to a specified key selector function. | 
        	
	| UnionBy<TSource,TKey>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) | Produces the set union of two sequences according to a specified key selector function. | 
        	
	| Where<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Boolean>) | Filters a sequence of values based on a predicate. | 
        	
	| Where<TSource>(IAsyncEnumerable<TSource>, Func<TSource,CancellationToken,ValueTask<Boolean>>) | Filters a sequence of values based on a predicate. | 
        	
	| Where<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Int32,Boolean>) | Filters a sequence of values based on a predicate.
Each element's index is used in the logic of the predicate function. | 
        	
	| Where<TSource>(IAsyncEnumerable<TSource>, Func<TSource,Int32,CancellationToken,ValueTask<Boolean>>) | Filters a sequence of values based on a predicate.
Each element's index is used in the logic of the predicate function. | 
        	
	| Zip<TFirst,TSecond,TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, Func<TFirst,TSecond,CancellationToken,ValueTask<TResult>>) | Applies a specified function to the corresponding elements of two sequences,
producing a sequence of the results. | 
        	
	| Zip<TFirst,TSecond,TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, Func<TFirst,TSecond,TResult>) | Applies a specified function to the corresponding elements of two sequences,
producing a sequence of the results. | 
        	
	| Zip<TFirst,TSecond,TThird>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>) | Produces a sequence of tuples with elements from the three specified sequences. | 
        	
	| Zip<TFirst,TSecond>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>) | Produces a sequence of tuples with elements from the two specified sequences. |