Interface IBuffer<T>

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

Inherited Members

IEnumerable<T>.GetEnumerator()

IDisposable.Dispose()

Namespace: SuperLinq

Assembly: SuperLinq.dll

Syntax

public interface IBuffer<out T> : IEnumerable<T>, IEnumerable, IDisposable

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
Reset()	Clears the current buffer and restarts the enumeration from the beginning.

Extension Methods

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, TAccumulate6, Func<TAccumulate6, T, TAccumulate6>, TAccumulate7, Func<TAccumulate7, T, TAccumulate7>, TAccumulate8, Func<TAccumulate8, T, TAccumulate8>, Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>)

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>)

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>)

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, Func<TAccumulate1, TAccumulate2, TResult>)

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>)

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, Func<TAccumulate1, TAccumulate2, TAccumulate3, TResult>)

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>)

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>)

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, TAccumulate6, Func<TAccumulate6, T, TAccumulate6>)

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>)

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, TAccumulate6, Func<TAccumulate6, T, TAccumulate6>, TAccumulate7, Func<TAccumulate7, T, TAccumulate7>)

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, TAccumulate6, Func<TAccumulate6, T, TAccumulate6>, Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>)

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, TAccumulate6, Func<TAccumulate6, T, TAccumulate6>, TAccumulate7, Func<TAccumulate7, T, TAccumulate7>, TAccumulate8, Func<TAccumulate8, T, TAccumulate8>)

SuperEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>(IEnumerable<T>, TAccumulate1, Func<TAccumulate1, T, TAccumulate1>, TAccumulate2, Func<TAccumulate2, T, TAccumulate2>, TAccumulate3, Func<TAccumulate3, T, TAccumulate3>, TAccumulate4, Func<TAccumulate4, T, TAccumulate4>, TAccumulate5, Func<TAccumulate5, T, TAccumulate5>, TAccumulate6, Func<TAccumulate6, T, TAccumulate6>, TAccumulate7, Func<TAccumulate7, T, TAccumulate7>, Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>)

SuperEnumerable.AggregateBy<TSource, TKey, TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>, IEqualityComparer<TKey>?)

SuperEnumerable.AggregateBy<TSource, TKey, TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, TAccumulate>, Func<TAccumulate, TSource, TAccumulate>, IEqualityComparer<TKey>?)

SuperEnumerable.AggregateRight<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>)

SuperEnumerable.AggregateRight<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, TAccumulate>)

SuperEnumerable.AggregateRight<TSource, TAccumulate, TResult>(IEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, TAccumulate>, Func<TAccumulate, TResult>)

SuperEnumerable.AssertCount<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.AtLeast<T>(IEnumerable<T>, int)

SuperEnumerable.AtMost<T>(IEnumerable<T>, int)

SuperEnumerable.Backsert<T>(IEnumerable<T>, IEnumerable<T>, int)

SuperEnumerable.Batch<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.Batch<TSource, TResult>(IEnumerable<TSource>, TSource[], SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>)

SuperEnumerable.Batch<TSource, TResult>(IEnumerable<TSource>, TSource[], int, SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>)

SuperEnumerable.Batch<TSource, TResult>(IEnumerable<TSource>, int, SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>)

SuperEnumerable.BindByIndex<TSource>(IEnumerable<TSource>, IEnumerable<int>)

SuperEnumerable.BindByIndex<TSource, TResult>(IEnumerable<TSource>, IEnumerable<int>, Func<TSource, int, TResult>, Func<int, TResult>)

SuperEnumerable.Buffer<TSource>(IEnumerable<TSource>, int, int)

SuperEnumerable.Buffer<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.Cartesian<T1, T2>(IEnumerable<T1>, IEnumerable<T2>)

SuperEnumerable.Cartesian<T1, T2, T3>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>)

SuperEnumerable.Cartesian<T1, T2, TResult>(IEnumerable<T1>, IEnumerable<T2>, Func<T1, T2, TResult>)

SuperEnumerable.Cartesian<T1, T2, T3, T4>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>)

SuperEnumerable.Cartesian<T1, T2, T3, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, Func<T1, T2, T3, TResult>)

SuperEnumerable.Cartesian<T1, T2, T3, T4, T5>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>)

SuperEnumerable.Cartesian<T1, T2, T3, T4, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, Func<T1, T2, T3, T4, TResult>)

SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, T6>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, IEnumerable<T6>)

SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, Func<T1, T2, T3, T4, T5, TResult>)

SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, IEnumerable<T6>, IEnumerable<T7>)

SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, IEnumerable<T6>, Func<T1, T2, T3, T4, T5, T6, TResult>)

SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, IEnumerable<T6>, IEnumerable<T7>, IEnumerable<T8>)

SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, IEnumerable<T6>, IEnumerable<T7>, Func<T1, T2, T3, T4, T5, T6, T7, TResult>)

SuperEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, IEnumerable<T5>, IEnumerable<T6>, IEnumerable<T7>, IEnumerable<T8>, Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult>)

SuperEnumerable.Catch<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

SuperEnumerable.Catch<TSource, TException>(IEnumerable<TSource>, Func<TException, IEnumerable<TSource>>)

SuperEnumerable.Choose<T, TResult>(IEnumerable<T>, Func<T, (bool, TResult)>)

SuperEnumerable.CollectionEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>?)

SuperEnumerable.CollectionEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

SuperEnumerable.CompareCount<TFirst, TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

SuperEnumerable.Consume<T>(IEnumerable<T>)

SuperEnumerable.CopyTo<TSource>(IEnumerable<TSource>, TSource[])

SuperEnumerable.CopyTo<TSource>(IEnumerable<TSource>, IList<TSource>, int)

SuperEnumerable.CopyTo<TSource>(IEnumerable<TSource>, IList<TSource>)

SuperEnumerable.CopyTo<TSource>(IEnumerable<TSource>, Span<TSource>)

SuperEnumerable.CountBetween<T>(IEnumerable<T>, int, int)

SuperEnumerable.CountBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

SuperEnumerable.CountBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)

SuperEnumerable.CountDown<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.CountDown<TSource, TResult>(IEnumerable<TSource>, int, Func<TSource, int?, TResult>)

SuperEnumerable.DensePartialSort<T>(IEnumerable<T>, int, OrderByDirection)

SuperEnumerable.DensePartialSort<T>(IEnumerable<T>, int, IComparer<T>?, OrderByDirection)

SuperEnumerable.DensePartialSort<T>(IEnumerable<T>, int, IComparer<T>?)

SuperEnumerable.DensePartialSort<T>(IEnumerable<T>, int)

SuperEnumerable.DensePartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>, OrderByDirection)

SuperEnumerable.DensePartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?, OrderByDirection)

SuperEnumerable.DensePartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?)

SuperEnumerable.DensePartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>)

SuperEnumerable.DenseRank<TSource>(IEnumerable<TSource>)

SuperEnumerable.DenseRank<TSource>(IEnumerable<TSource>, OrderByDirection)

SuperEnumerable.DenseRank<TSource>(IEnumerable<TSource>, IComparer<TSource>, OrderByDirection)

SuperEnumerable.DenseRank<TSource>(IEnumerable<TSource>, IComparer<TSource>)

SuperEnumerable.DenseRankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection)

SuperEnumerable.DenseRankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>, OrderByDirection)

SuperEnumerable.DenseRankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>)

SuperEnumerable.DenseRankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)

SuperEnumerable.DistinctUntilChanged<TSource>(IEnumerable<TSource>)

SuperEnumerable.DistinctUntilChanged<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>?)

SuperEnumerable.DistinctUntilChanged<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

SuperEnumerable.DistinctUntilChanged<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)

SuperEnumerable.Do<TSource>(IEnumerable<TSource>, Action<TSource>, Action)

SuperEnumerable.Do<TSource>(IEnumerable<TSource>, Action<TSource>, Action<Exception>, Action)

SuperEnumerable.Do<TSource>(IEnumerable<TSource>, Action<TSource>, Action<Exception>)

SuperEnumerable.Do<TSource>(IEnumerable<TSource>, Action<TSource>)

SuperEnumerable.DoWhile<TSource>(IEnumerable<TSource>, Func<bool>)

SuperEnumerable.Duplicates<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>?)

SuperEnumerable.EndsWith<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>?)

SuperEnumerable.EndsWith<T>(IEnumerable<T>, IEnumerable<T>)

SuperEnumerable.EquiZip<TFirst, TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

SuperEnumerable.EquiZip<TFirst, TSecond, TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)

SuperEnumerable.EquiZip<TFirst, TSecond, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst, TSecond, TResult>)

SuperEnumerable.EquiZip<TFirst, TSecond, TThird, TFourth>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>, IEnumerable<TFourth>)

SuperEnumerable.EquiZip<TFirst, TSecond, TThird, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>, Func<TFirst, TSecond, TThird, TResult>)

SuperEnumerable.EquiZip<TFirst, TSecond, TThird, TFourth, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>, IEnumerable<TFourth>, Func<TFirst, TSecond, TThird, TFourth, TResult>)

SuperEnumerable.Exactly<T>(IEnumerable<T>, int)

SuperEnumerable.ExceptBy<TSource, TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

SuperEnumerable.ExceptBy<TSource, TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource, TKey>)

SuperEnumerable.Exclude<T>(IEnumerable<T>, int, int)

SuperEnumerable.Exclude<T>(IEnumerable<T>, Range)

SuperEnumerable.FallbackIfEmpty<T>(IEnumerable<T>, params T[])

SuperEnumerable.FallbackIfEmpty<T>(IEnumerable<T>, IEnumerable<T>)

SuperEnumerable.FillBackward<T>(IEnumerable<T?>)

SuperEnumerable.FillBackward<T>(IEnumerable<T>, Func<T, bool>, Func<T, T, T>)

SuperEnumerable.FillBackward<T>(IEnumerable<T>, Func<T, bool>)

SuperEnumerable.FillForward<T>(IEnumerable<T?>)

SuperEnumerable.FillForward<T>(IEnumerable<T>, Func<T, bool>, Func<T, T, T>)

SuperEnumerable.FillForward<T>(IEnumerable<T>, Func<T, bool>)

SuperEnumerable.Finally<TSource>(IEnumerable<TSource>, Action)

SuperEnumerable.FindIndex<TSource>(IEnumerable<TSource>, Func<TSource, bool>, Index, int)

SuperEnumerable.FindIndex<TSource>(IEnumerable<TSource>, Func<TSource, bool>, Index)

SuperEnumerable.FindIndex<TSource>(IEnumerable<TSource>, Func<TSource, bool>)

SuperEnumerable.FindLastIndex<TSource>(IEnumerable<TSource>, Func<TSource, bool>, Index, int)

SuperEnumerable.FindLastIndex<TSource>(IEnumerable<TSource>, Func<TSource, bool>, Index)

SuperEnumerable.FindLastIndex<TSource>(IEnumerable<TSource>, Func<TSource, bool>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, T, TResult>)

SuperEnumerable.Fold<T, TResult>(IEnumerable<T>, Func<T, TResult>)

SuperEnumerable.ForEach<TSource>(IEnumerable<TSource>, Action<TSource, int>)

SuperEnumerable.ForEach<TSource>(IEnumerable<TSource>, Action<TSource>)

SuperEnumerable.FullGroupJoin<TFirst, TSecond, TKey>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst, TKey>, Func<TSecond, TKey>, IEqualityComparer<TKey>?)

SuperEnumerable.FullGroupJoin<TFirst, TSecond, TKey>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst, TKey>, Func<TSecond, TKey>)

SuperEnumerable.FullGroupJoin<TFirst, TSecond, TKey, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst, TKey>, Func<TSecond, TKey>, Func<TKey, IEnumerable<TFirst>, IEnumerable<TSecond>, TResult>, IEqualityComparer<TKey>?)

SuperEnumerable.FullGroupJoin<TFirst, TSecond, TKey, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst, TKey>, Func<TSecond, TKey>, Func<TKey, IEnumerable<TFirst>, IEnumerable<TSecond>, TResult>)

SuperEnumerable.FullOuterHashJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?)

SuperEnumerable.FullOuterHashJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?)

SuperEnumerable.FullOuterMergeJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?)

SuperEnumerable.FullOuterMergeJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IComparer<TKey>?)

SuperEnumerable.GroupAdjacent<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

SuperEnumerable.GroupAdjacent<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)

SuperEnumerable.GroupAdjacent<TSource, TKey, TElement>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>, IEqualityComparer<TKey>?)

SuperEnumerable.GroupAdjacent<TSource, TKey, TElement>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource, TElement>)

SuperEnumerable.GroupAdjacent<TSource, TKey, TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, IReadOnlyList<TSource>, TResult>, IEqualityComparer<TKey>?)

SuperEnumerable.GroupAdjacent<TSource, TKey, TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, IReadOnlyList<TSource>, TResult>)

SuperEnumerable.HasDuplicates<T>(IEnumerable<T>)

SuperEnumerable.HasDuplicates<T>(IEnumerable<T>, IEqualityComparer<T>?)

SuperEnumerable.HasDuplicates<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

SuperEnumerable.HasDuplicates<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)

SuperEnumerable.Index<TSource>(IEnumerable<TSource>)

SuperEnumerable.Index<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.IndexBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IEqualityComparer<TKey>?)

SuperEnumerable.IndexBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)

SuperEnumerable.IndexOf<TSource>(IEnumerable<TSource>, TSource, Index, int)

SuperEnumerable.IndexOf<TSource>(IEnumerable<TSource>, TSource, Index)

SuperEnumerable.IndexOf<TSource>(IEnumerable<TSource>, TSource)

SuperEnumerable.InnerHashJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?)

SuperEnumerable.InnerHashJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?)

SuperEnumerable.InnerLoopJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?)

SuperEnumerable.InnerLoopJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?)

SuperEnumerable.InnerMergeJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?)

SuperEnumerable.InnerMergeJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TRight, TResult>, IComparer<TKey>?)

SuperEnumerable.Insert<T>(IEnumerable<T>, IEnumerable<T>, Index)

SuperEnumerable.Insert<T>(IEnumerable<T>, IEnumerable<T>, int)

SuperEnumerable.Interleave<T>(IEnumerable<T>, params IEnumerable<T>[])

SuperEnumerable.Lag<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.Lag<TSource, TResult>(IEnumerable<TSource>, int, TSource, Func<TSource, TSource, TResult>)

SuperEnumerable.Lag<TSource, TResult>(IEnumerable<TSource>, int, Func<TSource, TSource?, TResult>)

SuperEnumerable.LastIndexOf<TSource>(IEnumerable<TSource>, TSource, Index, int)

SuperEnumerable.LastIndexOf<TSource>(IEnumerable<TSource>, TSource, Index)

SuperEnumerable.LastIndexOf<TSource>(IEnumerable<TSource>, TSource)

SuperEnumerable.Lead<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.Lead<TSource, TResult>(IEnumerable<TSource>, int, TSource, Func<TSource, TSource, TResult>)

SuperEnumerable.Lead<TSource, TResult>(IEnumerable<TSource>, int, Func<TSource, TSource?, TResult>)

SuperEnumerable.LeftOuterHashJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?)

SuperEnumerable.LeftOuterHashJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?)

SuperEnumerable.LeftOuterLoopJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?)

SuperEnumerable.LeftOuterLoopJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?)

SuperEnumerable.LeftOuterMergeJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?)

SuperEnumerable.LeftOuterMergeJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TLeft, TResult>, Func<TLeft, TRight, TResult>, IComparer<TKey>?)

SuperEnumerable.MaxByWithTies<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?)

SuperEnumerable.MaxByWithTies<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)

SuperEnumerable.MaxItems<T>(IEnumerable<T>)

SuperEnumerable.MaxItems<T>(IEnumerable<T>, IComparer<T>?)

SuperEnumerable.MaxItemsBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?)

SuperEnumerable.MaxItemsBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)

SuperEnumerable.Memoize<TSource>(IEnumerable<TSource>, bool)

SuperEnumerable.MinByWithTies<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?)

SuperEnumerable.MinByWithTies<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)

SuperEnumerable.MinItems<T>(IEnumerable<T>)

SuperEnumerable.MinItems<T>(IEnumerable<T>, IComparer<T>?)

SuperEnumerable.MinItemsBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?)

SuperEnumerable.MinItemsBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)

SuperEnumerable.Move<T>(IEnumerable<T>, int, int, int)

SuperEnumerable.OnErrorResumeNext<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

SuperEnumerable.OrderBy<T, TKey>(IEnumerable<T>, Func<T, TKey>, OrderByDirection)

SuperEnumerable.OrderBy<T, TKey>(IEnumerable<T>, Func<T, TKey>, IComparer<TKey>?, OrderByDirection)

SuperEnumerable.Pad<TSource>(IEnumerable<TSource>, int, TSource)

SuperEnumerable.Pad<TSource>(IEnumerable<TSource>, int, Func<int, TSource>)

SuperEnumerable.Pad<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.PadStart<TSource>(IEnumerable<TSource>, int, TSource)

SuperEnumerable.PadStart<TSource>(IEnumerable<TSource>, int, Func<int, TSource>)

SuperEnumerable.PadStart<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.PartialSort<T>(IEnumerable<T>, int, OrderByDirection)

SuperEnumerable.PartialSort<T>(IEnumerable<T>, int, IComparer<T>?, OrderByDirection)

SuperEnumerable.PartialSort<T>(IEnumerable<T>, int, IComparer<T>?)

SuperEnumerable.PartialSort<T>(IEnumerable<T>, int)

SuperEnumerable.PartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>, OrderByDirection)

SuperEnumerable.PartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?, OrderByDirection)

SuperEnumerable.PartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>, IComparer<TKey>?)

SuperEnumerable.PartialSortBy<TSource, TKey>(IEnumerable<TSource>, int, Func<TSource, TKey>)

SuperEnumerable.Partition<T>(IEnumerable<T>, Func<T, bool>)

SuperEnumerable.Partition<T, TResult>(IEnumerable<T>, Func<T, bool>, Func<IEnumerable<T>, IEnumerable<T>, TResult>)

SuperEnumerable.Permutations<T>(IEnumerable<T>)

SuperEnumerable.Pipe<TSource>(IEnumerable<TSource>, Action<TSource>)

SuperEnumerable.PreScan<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>, TSource)

SuperEnumerable.Publish<TSource>(IEnumerable<TSource>)

SuperEnumerable.RandomSubset<T>(IEnumerable<T>, int, Random)

SuperEnumerable.RandomSubset<T>(IEnumerable<T>, int)

SuperEnumerable.Rank<TSource>(IEnumerable<TSource>)

SuperEnumerable.Rank<TSource>(IEnumerable<TSource>, OrderByDirection)

SuperEnumerable.Rank<TSource>(IEnumerable<TSource>, IComparer<TSource>, OrderByDirection)

SuperEnumerable.Rank<TSource>(IEnumerable<TSource>, IComparer<TSource>)

SuperEnumerable.RankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection)

SuperEnumerable.RankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>, OrderByDirection)

SuperEnumerable.RankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>)

SuperEnumerable.RankBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>)

SuperEnumerable.Repeat<TSource>(IEnumerable<TSource>)

SuperEnumerable.Repeat<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.Replace<TSource>(IEnumerable<TSource>, Index, TSource)

SuperEnumerable.Replace<TSource>(IEnumerable<TSource>, int, TSource)

SuperEnumerable.Retry<TSource>(IEnumerable<TSource>)

SuperEnumerable.Retry<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.RightOuterHashJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IEqualityComparer<TKey>?)

SuperEnumerable.RightOuterHashJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IEqualityComparer<TKey>?)

SuperEnumerable.RightOuterMergeJoin<TLeft, TRight, TKey>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, IComparer<TKey>?)

SuperEnumerable.RightOuterMergeJoin<TLeft, TRight, TKey, TResult>(IEnumerable<TLeft>, IEnumerable<TRight>, Func<TLeft, TKey>, Func<TRight, TKey>, Func<TRight, TResult>, Func<TLeft, TRight, TResult>, IComparer<TKey>?)

SuperEnumerable.RunLengthEncode<T>(IEnumerable<T>)

SuperEnumerable.RunLengthEncode<T>(IEnumerable<T>, IEqualityComparer<T>?)

SuperEnumerable.Scan<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>)

SuperEnumerable.Scan<TSource, TState>(IEnumerable<TSource>, TState, Func<TState, TSource, TState>)

SuperEnumerable.ScanBy<TSource, TKey, TState>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, TState>, Func<TState, TKey, TSource, TState>, IEqualityComparer<TKey>?)

SuperEnumerable.ScanBy<TSource, TKey, TState>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey, TState>, Func<TState, TKey, TSource, TState>)

SuperEnumerable.ScanRight<TSource>(IEnumerable<TSource>, Func<TSource, TSource, TSource>)

SuperEnumerable.ScanRight<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TSource, TAccumulate, TAccumulate>)

SuperEnumerable.Segment<T>(IEnumerable<T>, Func<T, T, int, bool>)

SuperEnumerable.Segment<T>(IEnumerable<T>, Func<T, bool>)

SuperEnumerable.Segment<T>(IEnumerable<T>, Func<T, int, bool>)

SuperEnumerable.Share<TSource>(IEnumerable<TSource>)

SuperEnumerable.Shuffle<T>(IEnumerable<T>)

SuperEnumerable.Shuffle<T>(IEnumerable<T>, Random)

SuperEnumerable.SkipUntil<TSource>(IEnumerable<TSource>, Func<TSource, bool>)

SuperEnumerable.Slice<T>(IEnumerable<T>, int, int)

SuperEnumerable.SortedMerge<TSource>(IEnumerable<TSource>, OrderByDirection, IComparer<TSource>?, params IEnumerable<TSource>[])

SuperEnumerable.SortedMerge<TSource>(IEnumerable<TSource>, OrderByDirection, params IEnumerable<TSource>[])

SuperEnumerable.SortedMerge<TSource>(IEnumerable<TSource>, IComparer<TSource>?, params IEnumerable<TSource>[])

SuperEnumerable.SortedMerge<TSource>(IEnumerable<TSource>, params IEnumerable<TSource>[])

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

SuperEnumerable.SortedMergeBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, OrderByDirection, params IEnumerable<TSource>[])

SuperEnumerable.SortedMergeBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, IComparer<TKey>?, params IEnumerable<TSource>[])

SuperEnumerable.SortedMergeBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource, TKey>, params IEnumerable<TSource>[])

SuperEnumerable.Split<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>?, int)

SuperEnumerable.Split<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>?)

SuperEnumerable.Split<TSource>(IEnumerable<TSource>, TSource, int)

SuperEnumerable.Split<TSource>(IEnumerable<TSource>, TSource)

SuperEnumerable.Split<TSource>(IEnumerable<TSource>, Func<TSource, bool>, int)

SuperEnumerable.Split<TSource>(IEnumerable<TSource>, Func<TSource, bool>)

SuperEnumerable.Split<TSource, TResult>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>, Func<IReadOnlyList<TSource>, TResult>)

SuperEnumerable.Split<TSource, TResult>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>?, int, Func<IReadOnlyList<TSource>, TResult>)

SuperEnumerable.Split<TSource, TResult>(IEnumerable<TSource>, TSource, Func<IReadOnlyList<TSource>, TResult>)

SuperEnumerable.Split<TSource, TResult>(IEnumerable<TSource>, TSource, int, Func<IReadOnlyList<TSource>, TResult>)

SuperEnumerable.Split<TSource, TResult>(IEnumerable<TSource>, Func<TSource, bool>, Func<IReadOnlyList<TSource>, TResult>)

SuperEnumerable.Split<TSource, TResult>(IEnumerable<TSource>, Func<TSource, bool>, int, Func<IReadOnlyList<TSource>, TResult>)

SuperEnumerable.StartsWith<T>(IEnumerable<T>, IEnumerable<T>, IEqualityComparer<T>?)

SuperEnumerable.StartsWith<T>(IEnumerable<T>, IEnumerable<T>)

SuperEnumerable.Subsets<T>(IEnumerable<T>)

SuperEnumerable.Subsets<T>(IEnumerable<T>, int)

SuperEnumerable.TagFirstLast<TSource>(IEnumerable<TSource>)

SuperEnumerable.TagFirstLast<TSource, TResult>(IEnumerable<TSource>, Func<TSource, bool, bool, TResult>)

SuperEnumerable.TakeEvery<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.TakeUntil<TSource>(IEnumerable<TSource>, Func<TSource, bool>)

SuperEnumerable.ToArrayByIndex<T>(IEnumerable<T>, Func<T, int>)

SuperEnumerable.ToArrayByIndex<T>(IEnumerable<T>, int, Func<T, int>)

SuperEnumerable.ToArrayByIndex<T, TResult>(IEnumerable<T>, Func<T, int>, Func<T, TResult>)

SuperEnumerable.ToArrayByIndex<T, TResult>(IEnumerable<T>, Func<T, int>, Func<T, int, TResult>)

SuperEnumerable.ToArrayByIndex<T, TResult>(IEnumerable<T>, int, Func<T, int>, Func<T, TResult>)

SuperEnumerable.ToArrayByIndex<T, TResult>(IEnumerable<T>, int, Func<T, int>, Func<T, int, TResult>)

SuperEnumerable.ToDataTable<T>(IEnumerable<T>)

SuperEnumerable.ToDataTable<T>(IEnumerable<T>, params Expression<Func<T, object>>[])

SuperEnumerable.ToDataTable<T, TTable>(IEnumerable<T>, TTable, params Expression<Func<T, object>>[])

SuperEnumerable.ToDataTable<T, TTable>(IEnumerable<T>, TTable)

SuperEnumerable.ToDelimitedString<TSource>(IEnumerable<TSource>, string)

SuperEnumerable.TrySingle<TSource>(IEnumerable<TSource>)

SuperEnumerable.TrySingle<T, TCardinality>(IEnumerable<T>, TCardinality, TCardinality, TCardinality)

SuperEnumerable.TrySingle<T, TCardinality, TResult>(IEnumerable<T>, TCardinality, TCardinality, TCardinality, Func<TCardinality, T?, TResult>)

SuperEnumerable.Where<TSource>(IEnumerable<TSource>, IEnumerable<bool>)

SuperEnumerable.WhereLag<TSource>(IEnumerable<TSource>, int, TSource, Func<TSource, TSource, bool>)

SuperEnumerable.WhereLag<TSource>(IEnumerable<TSource>, int, Func<TSource, TSource?, bool>)

SuperEnumerable.WhereLead<TSource>(IEnumerable<TSource>, int, TSource, Func<TSource, TSource, bool>)

SuperEnumerable.WhereLead<TSource>(IEnumerable<TSource>, int, Func<TSource, TSource?, bool>)

SuperEnumerable.Window<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.Window<TSource, TResult>(IEnumerable<TSource>, TSource[], SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>)

SuperEnumerable.Window<TSource, TResult>(IEnumerable<TSource>, TSource[], int, SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>)

SuperEnumerable.Window<TSource, TResult>(IEnumerable<TSource>, int, SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>)

SuperEnumerable.WindowLeft<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.WindowLeft<TSource, TResult>(IEnumerable<TSource>, TSource[], SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>)

SuperEnumerable.WindowLeft<TSource, TResult>(IEnumerable<TSource>, TSource[], int, SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>)

SuperEnumerable.WindowLeft<TSource, TResult>(IEnumerable<TSource>, int, SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>)

SuperEnumerable.WindowRight<TSource>(IEnumerable<TSource>, int)

SuperEnumerable.WindowRight<TSource, TResult>(IEnumerable<TSource>, TSource[], SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>)

SuperEnumerable.WindowRight<TSource, TResult>(IEnumerable<TSource>, TSource[], int, SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>)

SuperEnumerable.WindowRight<TSource, TResult>(IEnumerable<TSource>, int, SuperEnumerable.ReadOnlySpanFunc<TSource, TResult>)

SuperEnumerable.ZipLongest<T1, T2>(IEnumerable<T1>, IEnumerable<T2>)

SuperEnumerable.ZipLongest<T1, T2, T3>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>)

SuperEnumerable.ZipLongest<T1, T2, TResult>(IEnumerable<T1>, IEnumerable<T2>, Func<T1?, T2?, TResult>)

SuperEnumerable.ZipLongest<T1, T2, T3, T4>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>)

SuperEnumerable.ZipLongest<T1, T2, T3, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, Func<T1?, T2?, T3?, TResult>)

SuperEnumerable.ZipLongest<T1, T2, T3, T4, TResult>(IEnumerable<T1>, IEnumerable<T2>, IEnumerable<T3>, IEnumerable<T4>, Func<T1?, T2?, T3?, T4?, TResult>)

SuperEnumerable.ZipMap<TSource, TResult>(IEnumerable<TSource>, Func<TSource, TResult>)

SuperEnumerable.ZipShortest<TFirst, TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

SuperEnumerable.ZipShortest<TFirst, TSecond, TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)

SuperEnumerable.ZipShortest<TFirst, TSecond, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst, TSecond, TResult>)

SuperEnumerable.ZipShortest<TFirst, TSecond, TThird, TFourth>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>, IEnumerable<TFourth>)

SuperEnumerable.ZipShortest<TFirst, TSecond, TThird, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>, Func<TFirst, TSecond, TThird, TResult>)

SuperEnumerable.ZipShortest<TFirst, TSecond, TThird, TFourth, TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>, IEnumerable<TFourth>, Func<TFirst, TSecond, TThird, TFourth, TResult>)

SuperEnumerable.Flatten(IEnumerable)

SuperEnumerable.Flatten(IEnumerable, Func<IEnumerable, bool>)

SuperEnumerable.Flatten(IEnumerable, Func<object?, IEnumerable?>)