Interface IAsyncBuffer<T>

Represents a cached sequence that can be re-enumerated multiple times.

Inherited Members

IAsyncEnumerable<T>.GetAsyncEnumerator(CancellationToken)

IAsyncDisposable.DisposeAsync()

Namespace: SuperLinq.Async

Assembly: SuperLinq.Async.dll

Syntax

public interface IAsyncBuffer<out T> : IAsyncEnumerable<T>, IAsyncDisposable

Type Parameters

Name	Description
T	The type of the items in the cached sequence.

Properties

Name	Description
Count	The number of elements currently cached.

Methods

Name	Description
ConfigureAwait(bool)	Configures how awaits on the tasks returned from an async disposable are performed.
Reset(CancellationToken)	Clears the current buffer and restarts the enumeration from the beginning.

Extension Methods

AsyncSuperEnumerable.AggregateBy<TSource, TKey, TAccumulate>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.AggregateBy<TSource, TKey, TAccumulate>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, TAccumulate>, Func<TAccumulate, TSource, TAccumulate>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.AggregateRight<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, TSource>, CancellationToken)

AsyncSuperEnumerable.AggregateRight<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, CancellationToken, ValueTask<TSource>>, CancellationToken)

AsyncSuperEnumerable.AggregateRight<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, ValueTask<TSource>>, CancellationToken)

AsyncSuperEnumerable.AggregateRight<TSource, TAccumulate>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, TAccumulate>, CancellationToken)

AsyncSuperEnumerable.AggregateRight<TSource, TAccumulate>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, CancellationToken, ValueTask<TAccumulate>>, CancellationToken)

AsyncSuperEnumerable.AggregateRight<TSource, TAccumulate>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, ValueTask<TAccumulate>>, CancellationToken)

AsyncSuperEnumerable.AggregateRight<TSource, TAccumulate, TResult>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, TAccumulate>, Func<TAccumulate, TResult>, CancellationToken)

AsyncSuperEnumerable.AggregateRight<TSource, TAccumulate, TResult>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, CancellationToken, ValueTask<TAccumulate>>, Func<TAccumulate, CancellationToken, ValueTask<TResult>>, CancellationToken)

AsyncSuperEnumerable.AggregateRight<TSource, TAccumulate, TResult>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, ValueTask<TAccumulate>>, Func<TAccumulate, ValueTask<TResult>>, CancellationToken)

AsyncSuperEnumerable.Amb<TSource>(IAsyncEnumerable<TSource>, params IAsyncEnumerable<TSource>[])

AsyncSuperEnumerable.AssertCount<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.AtLeast<T>(IAsyncEnumerable<T>, int, CancellationToken)

AsyncSuperEnumerable.AtMost<T>(IAsyncEnumerable<T>, int, CancellationToken)

AsyncSuperEnumerable.Batch<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.BindByIndex<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<int>)

AsyncSuperEnumerable.BindByIndex<TSource, TResult>(IAsyncEnumerable<TSource>, IAsyncEnumerable<int>, Func<TSource, int, TResult>, Func<int, TResult>)

AsyncSuperEnumerable.Buffer<TSource>(IAsyncEnumerable<TSource>, int, int)

AsyncSuperEnumerable.Buffer<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.Catch<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>)

AsyncSuperEnumerable.Catch<TSource, TException>(IAsyncEnumerable<TSource>, Func<TException, IAsyncEnumerable<TSource>>)

AsyncSuperEnumerable.Choose<T, TResult>(IAsyncEnumerable<T>, Func<T, CancellationToken, ValueTask<(bool, TResult)>>)

AsyncSuperEnumerable.Choose<T, TResult>(IAsyncEnumerable<T>, Func<T, ValueTask<(bool, TResult)>>)

AsyncSuperEnumerable.Choose<T, TResult>(IAsyncEnumerable<T>, Func<T, (bool, TResult)>)

AsyncSuperEnumerable.CollectionEqual<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, IEqualityComparer<TSource>?, CancellationToken)

AsyncSuperEnumerable.CollectionEqual<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, CancellationToken)

AsyncSuperEnumerable.CompareCount<TFirst, TSecond>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, CancellationToken)

AsyncSuperEnumerable.ConcurrentMerge<TSource>(IAsyncEnumerable<TSource>, params IAsyncEnumerable<TSource>[])

AsyncSuperEnumerable.Consume<T>(IAsyncEnumerable<T>, CancellationToken)

AsyncSuperEnumerable.CopyTo<TSource>(IAsyncEnumerable<TSource>, IList<TSource>, int, CancellationToken)

AsyncSuperEnumerable.CopyTo<TSource>(IAsyncEnumerable<TSource>, IList<TSource>, CancellationToken)

AsyncSuperEnumerable.CountBetween<T>(IAsyncEnumerable<T>, int, int, CancellationToken)

AsyncSuperEnumerable.CountBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.CountBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.CountDown<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.CountDown<TSource, TResult>(IAsyncEnumerable<TSource>, int, Func<TSource, int?, TResult>)

AsyncSuperEnumerable.DensePartialSort<T>(IAsyncEnumerable<T>, int, OrderByDirection)

AsyncSuperEnumerable.DensePartialSort<T>(IAsyncEnumerable<T>, int, IComparer<T>?, OrderByDirection)

AsyncSuperEnumerable.DensePartialSort<T>(IAsyncEnumerable<T>, int, IComparer<T>?)

AsyncSuperEnumerable.DensePartialSort<T>(IAsyncEnumerable<T>, int)

AsyncSuperEnumerable.DensePartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>, OrderByDirection)

AsyncSuperEnumerable.DensePartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?, OrderByDirection)

AsyncSuperEnumerable.DensePartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?)

AsyncSuperEnumerable.DensePartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>)

AsyncSuperEnumerable.DenseRank<TSource>(IAsyncEnumerable<TSource>)

AsyncSuperEnumerable.DenseRank<TSource>(IAsyncEnumerable<TSource>, OrderByDirection)

AsyncSuperEnumerable.DenseRank<TSource>(IAsyncEnumerable<TSource>, IComparer<TSource>, OrderByDirection)

AsyncSuperEnumerable.DenseRank<TSource>(IAsyncEnumerable<TSource>, IComparer<TSource>)

AsyncSuperEnumerable.DenseRankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection)

AsyncSuperEnumerable.DenseRankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>, OrderByDirection)

AsyncSuperEnumerable.DenseRankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>)

AsyncSuperEnumerable.DenseRankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.DistinctBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.DistinctBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.DistinctUntilChanged<TSource>(IAsyncEnumerable<TSource>)

AsyncSuperEnumerable.DistinctUntilChanged<TSource>(IAsyncEnumerable<TSource>, IEqualityComparer<TSource>?)

AsyncSuperEnumerable.DistinctUntilChanged<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.DistinctUntilChanged<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.DistinctUntilChanged<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask<TKey>>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.DistinctUntilChanged<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask<TKey>>)

AsyncSuperEnumerable.Do<TSource>(IAsyncEnumerable<TSource>, Action<TSource>, Action)

AsyncSuperEnumerable.Do<TSource>(IAsyncEnumerable<TSource>, Action<TSource>, Action<Exception>, Action)

AsyncSuperEnumerable.Do<TSource>(IAsyncEnumerable<TSource>, Action<TSource>, Action<Exception>)

AsyncSuperEnumerable.Do<TSource>(IAsyncEnumerable<TSource>, Action<TSource>)

AsyncSuperEnumerable.Do<TSource>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask>, Func<Exception, ValueTask>, Func<ValueTask>)

AsyncSuperEnumerable.Do<TSource>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask>, Func<Exception, ValueTask>)

AsyncSuperEnumerable.Do<TSource>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask>, Func<ValueTask>)

AsyncSuperEnumerable.Do<TSource>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask>)

AsyncSuperEnumerable.DoWhile<TSource>(IAsyncEnumerable<TSource>, Func<bool>)

AsyncSuperEnumerable.DoWhile<TSource>(IAsyncEnumerable<TSource>, Func<ValueTask<bool>>)

AsyncSuperEnumerable.Duplicates<TSource>(IAsyncEnumerable<TSource>, IEqualityComparer<TSource>?)

AsyncSuperEnumerable.ElementAtAsync<TSource>(IAsyncEnumerable<TSource>, Index, CancellationToken)

AsyncSuperEnumerable.ElementAtOrDefaultAsync<TSource>(IAsyncEnumerable<TSource>, Index, CancellationToken)

AsyncSuperEnumerable.EndsWith<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>, IEqualityComparer<T>?, CancellationToken)

AsyncSuperEnumerable.EndsWith<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>, CancellationToken)

AsyncSuperEnumerable.EndsWith<T>(IAsyncEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>?, CancellationToken)

AsyncSuperEnumerable.EndsWith<T>(IAsyncEnumerable<T>, IEnumerable<T>, CancellationToken)

AsyncSuperEnumerable.EquiZip<TFirst, TSecond>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>)

AsyncSuperEnumerable.EquiZip<TFirst, TSecond, TThird>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>)

AsyncSuperEnumerable.EquiZip<TFirst, TSecond, TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, Func<TFirst, TSecond, TResult>)

AsyncSuperEnumerable.EquiZip<TFirst, TSecond, TThird, TFourth>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>, IAsyncEnumerable<TFourth>)

AsyncSuperEnumerable.EquiZip<TFirst, TSecond, TThird, TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>, Func<TFirst, TSecond, TThird, TResult>)

AsyncSuperEnumerable.EquiZip<TFirst, TSecond, TThird, TFourth, TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>, IAsyncEnumerable<TFourth>, Func<TFirst, TSecond, TThird, TFourth, TResult>)

AsyncSuperEnumerable.Exactly<T>(IAsyncEnumerable<T>, int, CancellationToken)

AsyncSuperEnumerable.ExceptBy<TSource, TKey>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.ExceptBy<TSource, TKey>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.FallbackIfEmpty<T>(IAsyncEnumerable<T>, params T[])

AsyncSuperEnumerable.FallbackIfEmpty<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>)

AsyncSuperEnumerable.FallbackIfEmpty<T>(IAsyncEnumerable<T>, IEnumerable<T>)

AsyncSuperEnumerable.FillBackward<T>(IAsyncEnumerable<T>)

AsyncSuperEnumerable.FillBackward<T>(IAsyncEnumerable<T>, Func<T, bool>, Func<T, T, T>)

AsyncSuperEnumerable.FillBackward<T>(IAsyncEnumerable<T>, Func<T, bool>, Func<T, T, ValueTask<T>>)

AsyncSuperEnumerable.FillBackward<T>(IAsyncEnumerable<T>, Func<T, bool>)

AsyncSuperEnumerable.FillBackward<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>, Func<T, T, T>)

AsyncSuperEnumerable.FillBackward<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>, Func<T, T, ValueTask<T>>)

AsyncSuperEnumerable.FillBackward<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>)

AsyncSuperEnumerable.FillForward<T>(IAsyncEnumerable<T>)

AsyncSuperEnumerable.FillForward<T>(IAsyncEnumerable<T>, Func<T, bool>, Func<T, T, T>)

AsyncSuperEnumerable.FillForward<T>(IAsyncEnumerable<T>, Func<T, bool>, Func<T, T, ValueTask<T>>)

AsyncSuperEnumerable.FillForward<T>(IAsyncEnumerable<T>, Func<T, bool>)

AsyncSuperEnumerable.FillForward<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>, Func<T, T, T>)

AsyncSuperEnumerable.FillForward<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>, Func<T, T, ValueTask<T>>)

AsyncSuperEnumerable.FillForward<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>)

AsyncSuperEnumerable.Finally<TSource>(IAsyncEnumerable<TSource>, Action)

AsyncSuperEnumerable.FindIndex<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, Index, int, CancellationToken)

AsyncSuperEnumerable.FindIndex<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, Index, CancellationToken)

AsyncSuperEnumerable.FindIndex<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, CancellationToken)

AsyncSuperEnumerable.FindLastIndex<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, Index, int, CancellationToken)

AsyncSuperEnumerable.FindLastIndex<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, Index, CancellationToken)

AsyncSuperEnumerable.FindLastIndex<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, CancellationToken)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, T, TResult>)

AsyncSuperEnumerable.Fold<T, TResult>(IAsyncEnumerable<T>, Func<T, TResult>)

AsyncSuperEnumerable.ForEach<TSource>(IAsyncEnumerable<TSource>, Action<TSource, int>, CancellationToken)

AsyncSuperEnumerable.ForEach<TSource>(IAsyncEnumerable<TSource>, Action<TSource>, CancellationToken)

AsyncSuperEnumerable.ForEach<TSource>(IAsyncEnumerable<TSource>, Func<TSource, int, ValueTask>, CancellationToken)

AsyncSuperEnumerable.ForEach<TSource>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask>, CancellationToken)

AsyncSuperEnumerable.FullOuterHashJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.FullOuterHashJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.FullOuterMergeJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?)

AsyncSuperEnumerable.FullOuterMergeJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IComparer<TKey>?)

AsyncSuperEnumerable.GroupAdjacent<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.GroupAdjacent<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.GroupAdjacent<TSource, TKey, TElement>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.GroupAdjacent<TSource, TKey, TElement>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>)

AsyncSuperEnumerable.GroupAdjacent<TSource, TKey, TResult>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, IReadOnlyList<TSource>, TResult>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.GroupAdjacent<TSource, TKey, TResult>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, IReadOnlyList<TSource>, TResult>)

AsyncSuperEnumerable.HasDuplicates<T>(IAsyncEnumerable<T>)

AsyncSuperEnumerable.HasDuplicates<T>(IAsyncEnumerable<T>, IEqualityComparer<T>?)

AsyncSuperEnumerable.HasDuplicates<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.HasDuplicates<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.Index<TSource>(IAsyncEnumerable<TSource>)

AsyncSuperEnumerable.Index<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.IndexBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.IndexBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.IndexOf<TSource>(IAsyncEnumerable<TSource>, TSource, Index, int, CancellationToken)

AsyncSuperEnumerable.IndexOf<TSource>(IAsyncEnumerable<TSource>, TSource, Index, CancellationToken)

AsyncSuperEnumerable.IndexOf<TSource>(IAsyncEnumerable<TSource>, TSource, CancellationToken)

AsyncSuperEnumerable.InnerHashJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.InnerHashJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.InnerLoopJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.InnerLoopJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.InnerMergeJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?)

AsyncSuperEnumerable.InnerMergeJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TRight, TResult>, IComparer<TKey>?)

AsyncSuperEnumerable.Insert<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>, Index)

AsyncSuperEnumerable.Insert<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>, int)

AsyncSuperEnumerable.Interleave<T>(IAsyncEnumerable<T>, params IAsyncEnumerable<T>[])

AsyncSuperEnumerable.IntersectBy<TSource, TKey>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.IntersectBy<TSource, TKey>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.Lag<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.Lag<TSource, TResult>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, TResult>)

AsyncSuperEnumerable.Lag<TSource, TResult>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, ValueTask<TResult>>)

AsyncSuperEnumerable.Lag<TSource, TResult>(IAsyncEnumerable<TSource>, int, Func<TSource, TSource?, TResult>)

AsyncSuperEnumerable.LastIndexOf<TSource>(IAsyncEnumerable<TSource>, TSource, Index, int, CancellationToken)

AsyncSuperEnumerable.LastIndexOf<TSource>(IAsyncEnumerable<TSource>, TSource, Index, CancellationToken)

AsyncSuperEnumerable.LastIndexOf<TSource>(IAsyncEnumerable<TSource>, TSource, CancellationToken)

AsyncSuperEnumerable.Lead<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.Lead<TSource, TResult>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, TResult>)

AsyncSuperEnumerable.Lead<TSource, TResult>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, ValueTask<TResult>>)

AsyncSuperEnumerable.Lead<TSource, TResult>(IAsyncEnumerable<TSource>, int, Func<TSource, TSource?, TResult>)

AsyncSuperEnumerable.LeftOuterHashJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.LeftOuterHashJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.LeftOuterLoopJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.LeftOuterLoopJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.LeftOuterMergeJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?)

AsyncSuperEnumerable.LeftOuterMergeJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TLeft, TRight, TResult>, IComparer<TKey>?)

AsyncSuperEnumerable.MaxByWithTies<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?)

AsyncSuperEnumerable.MaxByWithTies<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.MaxItems<T>(IAsyncEnumerable<T>)

AsyncSuperEnumerable.MaxItems<T>(IAsyncEnumerable<T>, IComparer<T>?)

AsyncSuperEnumerable.MaxItemsBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?)

AsyncSuperEnumerable.MaxItemsBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.Memoize<TSource>(IAsyncEnumerable<TSource>)

AsyncSuperEnumerable.MinByWithTies<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?)

AsyncSuperEnumerable.MinByWithTies<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.MinItems<T>(IAsyncEnumerable<T>)

AsyncSuperEnumerable.MinItems<T>(IAsyncEnumerable<T>, IComparer<T>?)

AsyncSuperEnumerable.MinItemsBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?)

AsyncSuperEnumerable.MinItemsBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.OnErrorResumeNext<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<TSource>)

AsyncSuperEnumerable.OrderBy<T, TKey>(IAsyncEnumerable<T>, Func<T, TKey>, OrderByDirection)

AsyncSuperEnumerable.OrderBy<T, TKey>(IAsyncEnumerable<T>, Func<T, TKey>, IComparer<TKey>, OrderByDirection)

AsyncSuperEnumerable.Pad<TSource>(IAsyncEnumerable<TSource>, int, TSource)

AsyncSuperEnumerable.Pad<TSource>(IAsyncEnumerable<TSource>, int, Func<int, TSource>)

AsyncSuperEnumerable.Pad<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.PadStart<TSource>(IAsyncEnumerable<TSource>, int, TSource)

AsyncSuperEnumerable.PadStart<TSource>(IAsyncEnumerable<TSource>, int, Func<int, TSource>)

AsyncSuperEnumerable.PadStart<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.PartialSort<T>(IAsyncEnumerable<T>, int, OrderByDirection)

AsyncSuperEnumerable.PartialSort<T>(IAsyncEnumerable<T>, int, IComparer<T>?, OrderByDirection)

AsyncSuperEnumerable.PartialSort<T>(IAsyncEnumerable<T>, int, IComparer<T>?)

AsyncSuperEnumerable.PartialSort<T>(IAsyncEnumerable<T>, int)

AsyncSuperEnumerable.PartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>, OrderByDirection)

AsyncSuperEnumerable.PartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?, OrderByDirection)

AsyncSuperEnumerable.PartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?)

AsyncSuperEnumerable.PartialSortBy<TSource, TKey>(IAsyncEnumerable<TSource>, int, Func<TSource, TKey>)

AsyncSuperEnumerable.Partition<T>(IAsyncEnumerable<T>, Func<T, bool>, CancellationToken)

AsyncSuperEnumerable.Partition<T, TResult>(IAsyncEnumerable<T>, Func<T, bool>, Func<IEnumerable<T>, IEnumerable<T>, TResult>, CancellationToken)

AsyncSuperEnumerable.PreScan<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, TSource>, TSource)

AsyncSuperEnumerable.Publish<TSource>(IAsyncEnumerable<TSource>)

AsyncSuperEnumerable.Rank<TSource>(IAsyncEnumerable<TSource>)

AsyncSuperEnumerable.Rank<TSource>(IAsyncEnumerable<TSource>, OrderByDirection)

AsyncSuperEnumerable.Rank<TSource>(IAsyncEnumerable<TSource>, IComparer<TSource>, OrderByDirection)

AsyncSuperEnumerable.Rank<TSource>(IAsyncEnumerable<TSource>, IComparer<TSource>)

AsyncSuperEnumerable.RankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection)

AsyncSuperEnumerable.RankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>, OrderByDirection)

AsyncSuperEnumerable.RankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>)

AsyncSuperEnumerable.RankBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>)

AsyncSuperEnumerable.Repeat<TSource>(IAsyncEnumerable<TSource>)

AsyncSuperEnumerable.Repeat<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.Replace<TSource>(IAsyncEnumerable<TSource>, Index, TSource)

AsyncSuperEnumerable.Replace<TSource>(IAsyncEnumerable<TSource>, int, TSource)

AsyncSuperEnumerable.Retry<TSource>(IAsyncEnumerable<TSource>)

AsyncSuperEnumerable.Retry<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.RightOuterHashJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.RightOuterHashJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.RightOuterMergeJoin<TLeft, TRight, TKey>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?)

AsyncSuperEnumerable.RightOuterMergeJoin<TLeft, TRight, TKey, TResult>(IAsyncEnumerable<TLeft>, IAsyncEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IComparer<TKey>?)

AsyncSuperEnumerable.RunLengthEncode<T>(IAsyncEnumerable<T>)

AsyncSuperEnumerable.RunLengthEncode<T>(IAsyncEnumerable<T>, IEqualityComparer<T>?)

AsyncSuperEnumerable.Scan<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, TSource>)

AsyncSuperEnumerable.Scan<TSource, TState>(IAsyncEnumerable<TSource>, TState, Func<TState, TSource, TState>)

AsyncSuperEnumerable.ScanBy<TSource, TKey, TState>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, TState>, Func<TState, TKey, TSource, TState>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.ScanBy<TSource, TKey, TState>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, TState>, Func<TState, TKey, TSource, TState>)

AsyncSuperEnumerable.ScanBy<TSource, TKey, TState>(IAsyncEnumerable<TSource>, Func<TSource, CancellationToken, ValueTask<TKey>>, Func<TKey, CancellationToken, ValueTask<TState>>, Func<TState, TKey, TSource, CancellationToken, ValueTask<TState>>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.ScanBy<TSource, TKey, TState>(IAsyncEnumerable<TSource>, Func<TSource, CancellationToken, ValueTask<TKey>>, Func<TKey, CancellationToken, ValueTask<TState>>, Func<TState, TKey, TSource, CancellationToken, ValueTask<TState>>)

AsyncSuperEnumerable.ScanBy<TSource, TKey, TState>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask<TKey>>, Func<TKey, ValueTask<TState>>, Func<TState, TKey, TSource, ValueTask<TState>>, IEqualityComparer<TKey>?)

AsyncSuperEnumerable.ScanBy<TSource, TKey, TState>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask<TKey>>, Func<TKey, ValueTask<TState>>, Func<TState, TKey, TSource, ValueTask<TState>>)

AsyncSuperEnumerable.ScanRight<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, TSource>)

AsyncSuperEnumerable.ScanRight<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, CancellationToken, ValueTask<TSource>>)

AsyncSuperEnumerable.ScanRight<TSource>(IAsyncEnumerable<TSource>, Func<TSource, TSource, ValueTask<TSource>>)

AsyncSuperEnumerable.ScanRight<TSource, TAccumulate>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, TAccumulate>)

AsyncSuperEnumerable.ScanRight<TSource, TAccumulate>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, CancellationToken, ValueTask<TAccumulate>>)

AsyncSuperEnumerable.ScanRight<TSource, TAccumulate>(IAsyncEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, ValueTask<TAccumulate>>)

AsyncSuperEnumerable.Segment<T>(IAsyncEnumerable<T>, Func<T, T, int, bool>)

AsyncSuperEnumerable.Segment<T>(IAsyncEnumerable<T>, Func<T, T, int, ValueTask<bool>>)

AsyncSuperEnumerable.Segment<T>(IAsyncEnumerable<T>, Func<T, bool>)

AsyncSuperEnumerable.Segment<T>(IAsyncEnumerable<T>, Func<T, int, bool>)

AsyncSuperEnumerable.Segment<T>(IAsyncEnumerable<T>, Func<T, int, ValueTask<bool>>)

AsyncSuperEnumerable.Segment<T>(IAsyncEnumerable<T>, Func<T, ValueTask<bool>>)

AsyncSuperEnumerable.Share<TSource>(IAsyncEnumerable<TSource>)

AsyncSuperEnumerable.SkipUntil<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>)

AsyncSuperEnumerable.SortedMerge<TSource>(IAsyncEnumerable<TSource>, OrderByDirection, params IAsyncEnumerable<TSource>[])

AsyncSuperEnumerable.SortedMerge<TSource>(IAsyncEnumerable<TSource>, OrderByDirection, IComparer<TSource>?, params IAsyncEnumerable<TSource>[])

AsyncSuperEnumerable.SortedMerge<TSource>(IAsyncEnumerable<TSource>, params IAsyncEnumerable<TSource>[])

AsyncSuperEnumerable.SortedMerge<TSource>(IAsyncEnumerable<TSource>, IComparer<TSource>?, params IAsyncEnumerable<TSource>[])

AsyncSuperEnumerable.SortedMergeBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection, params IAsyncEnumerable<TSource>[])

AsyncSuperEnumerable.SortedMergeBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection, IComparer<TKey>?, params IAsyncEnumerable<TSource>[])

AsyncSuperEnumerable.SortedMergeBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, params IAsyncEnumerable<TSource>[])

AsyncSuperEnumerable.SortedMergeBy<TSource, TKey>(IAsyncEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?, params IAsyncEnumerable<TSource>[])

AsyncSuperEnumerable.Split<TSource>(IAsyncEnumerable<TSource>, TSource, IEqualityComparer<TSource>?, int)

AsyncSuperEnumerable.Split<TSource>(IAsyncEnumerable<TSource>, TSource, IEqualityComparer<TSource>?)

AsyncSuperEnumerable.Split<TSource>(IAsyncEnumerable<TSource>, TSource, int)

AsyncSuperEnumerable.Split<TSource>(IAsyncEnumerable<TSource>, TSource)

AsyncSuperEnumerable.Split<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>, int)

AsyncSuperEnumerable.Split<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>)

AsyncSuperEnumerable.Split<TSource, TResult>(IAsyncEnumerable<TSource>, TSource, IEqualityComparer<TSource>, Func<IReadOnlyList<TSource>, TResult>)

AsyncSuperEnumerable.Split<TSource, TResult>(IAsyncEnumerable<TSource>, TSource, IEqualityComparer<TSource>?, int, Func<IReadOnlyList<TSource>, TResult>)

AsyncSuperEnumerable.Split<TSource, TResult>(IAsyncEnumerable<TSource>, TSource, Func<IReadOnlyList<TSource>, TResult>)

AsyncSuperEnumerable.Split<TSource, TResult>(IAsyncEnumerable<TSource>, TSource, int, Func<IReadOnlyList<TSource>, TResult>)

AsyncSuperEnumerable.Split<TSource, TResult>(IAsyncEnumerable<TSource>, Func<TSource, bool>, Func<IReadOnlyList<TSource>, TResult>)

AsyncSuperEnumerable.Split<TSource, TResult>(IAsyncEnumerable<TSource>, Func<TSource, bool>, int, Func<IReadOnlyList<TSource>, TResult>)

AsyncSuperEnumerable.StartsWith<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>, IEqualityComparer<T>?, CancellationToken)

AsyncSuperEnumerable.StartsWith<T>(IAsyncEnumerable<T>, IAsyncEnumerable<T>, CancellationToken)

AsyncSuperEnumerable.StartsWith<T>(IAsyncEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>?, CancellationToken)

AsyncSuperEnumerable.StartsWith<T>(IAsyncEnumerable<T>, IEnumerable<T>, CancellationToken)

AsyncSuperEnumerable.TagFirstLast<TSource>(IAsyncEnumerable<TSource>)

AsyncSuperEnumerable.TagFirstLast<TSource, TResult>(IAsyncEnumerable<TSource>, Func<TSource, bool, bool, TResult>)

AsyncSuperEnumerable.Take<TSource>(IAsyncEnumerable<TSource>, Range)

AsyncSuperEnumerable.TakeEvery<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.TakeUntil<TSource>(IAsyncEnumerable<TSource>, Func<TSource, bool>)

AsyncSuperEnumerable.Timeout<TSource>(IAsyncEnumerable<TSource>, TimeSpan)

AsyncSuperEnumerable.TrySingle<TSource>(IAsyncEnumerable<TSource>, CancellationToken)

AsyncSuperEnumerable.TrySingle<T, TCardinality>(IAsyncEnumerable<T>, TCardinality, TCardinality, TCardinality, CancellationToken)

AsyncSuperEnumerable.TrySingle<T, TCardinality, TResult>(IAsyncEnumerable<T>, TCardinality, TCardinality, TCardinality, Func<TCardinality, T?, TResult>, CancellationToken)

AsyncSuperEnumerable.Where<TSource>(IAsyncEnumerable<TSource>, IAsyncEnumerable<bool>)

AsyncSuperEnumerable.WhereLag<TSource>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, bool>)

AsyncSuperEnumerable.WhereLag<TSource>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, ValueTask<bool>>)

AsyncSuperEnumerable.WhereLag<TSource>(IAsyncEnumerable<TSource>, int, Func<TSource, TSource?, bool>)

AsyncSuperEnumerable.WhereLag<TSource>(IAsyncEnumerable<TSource>, int, Func<TSource, TSource?, ValueTask<bool>>)

AsyncSuperEnumerable.WhereLead<TSource>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, bool>)

AsyncSuperEnumerable.WhereLead<TSource>(IAsyncEnumerable<TSource>, int, TSource, Func<TSource, TSource, ValueTask<bool>>)

AsyncSuperEnumerable.WhereLead<TSource>(IAsyncEnumerable<TSource>, int, Func<TSource, TSource?, bool>)

AsyncSuperEnumerable.WhereLead<TSource>(IAsyncEnumerable<TSource>, int, Func<TSource, TSource?, ValueTask<bool>>)

AsyncSuperEnumerable.Window<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.WindowLeft<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.WindowRight<TSource>(IAsyncEnumerable<TSource>, int)

AsyncSuperEnumerable.ZipLongest<T1, T2>(IAsyncEnumerable<T1>, IAsyncEnumerable<T2>)

AsyncSuperEnumerable.ZipLongest<T1, T2, T3>(IAsyncEnumerable<T1>, IAsyncEnumerable<T2>, IAsyncEnumerable<T3>)

AsyncSuperEnumerable.ZipLongest<T1, T2, TResult>(IAsyncEnumerable<T1>, IAsyncEnumerable<T2>, Func<T1?, T2?, TResult>)

AsyncSuperEnumerable.ZipLongest<T1, T2, T3, T4>(IAsyncEnumerable<T1>, IAsyncEnumerable<T2>, IAsyncEnumerable<T3>, IAsyncEnumerable<T4>)

AsyncSuperEnumerable.ZipLongest<T1, T2, T3, TResult>(IAsyncEnumerable<T1>, IAsyncEnumerable<T2>, IAsyncEnumerable<T3>, Func<T1?, T2?, T3?, TResult>)

AsyncSuperEnumerable.ZipLongest<T1, T2, T3, T4, TResult>(IAsyncEnumerable<T1>, IAsyncEnumerable<T2>, IAsyncEnumerable<T3>, IAsyncEnumerable<T4>, Func<T1?, T2?, T3?, T4?, TResult>)

AsyncSuperEnumerable.ZipMap<TSource, TResult>(IAsyncEnumerable<TSource>, Func<TSource, TResult>)

AsyncSuperEnumerable.ZipMap<TSource, TResult>(IAsyncEnumerable<TSource>, Func<TSource, CancellationToken, ValueTask<TResult>>)

AsyncSuperEnumerable.ZipMap<TSource, TResult>(IAsyncEnumerable<TSource>, Func<TSource, ValueTask<TResult>>)

AsyncSuperEnumerable.ZipShortest<TFirst, TSecond>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>)

AsyncSuperEnumerable.ZipShortest<TFirst, TSecond, TThird>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>)

AsyncSuperEnumerable.ZipShortest<TFirst, TSecond, TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, Func<TFirst, TSecond, TResult>)

AsyncSuperEnumerable.ZipShortest<TFirst, TSecond, TThird, TFourth>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>, IAsyncEnumerable<TFourth>)

AsyncSuperEnumerable.ZipShortest<TFirst, TSecond, TThird, TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>, Func<TFirst, TSecond, TThird, TResult>)

AsyncSuperEnumerable.ZipShortest<TFirst, TSecond, TThird, TFourth, TResult>(IAsyncEnumerable<TFirst>, IAsyncEnumerable<TSecond>, IAsyncEnumerable<TThird>, IAsyncEnumerable<TFourth>, Func<TFirst, TSecond, TThird, TFourth, TResult>)