#nullable enable
~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func<object, System.Collections.IEnumerable?>! selector) -> System.Collections.Generic.IEnumerable<object>!
~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func<System.Collections.IEnumerable!, bool>! predicate) -> System.Collections.Generic.IEnumerable<object>!
~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable<object>!
~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func<object, System.Collections.IEnumerable?>! selector) -> System.Collections.Generic.IEnumerable<object>!
~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func<System.Collections.IEnumerable!, bool>! predicate) -> System.Collections.Generic.IEnumerable<object>!
~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable<object>!
MoreLinq.Experimental.AwaitQueryOptions
MoreLinq.Experimental.AwaitQueryOptions.MaxConcurrency.get -> int?
MoreLinq.Experimental.AwaitQueryOptions.PreserveOrder.get -> bool
MoreLinq.Experimental.AwaitQueryOptions.Scheduler.get -> System.Threading.Tasks.TaskScheduler!
MoreLinq.Experimental.AwaitQueryOptions.WithMaxConcurrency(int? value) -> MoreLinq.Experimental.AwaitQueryOptions!
MoreLinq.Experimental.AwaitQueryOptions.WithPreserveOrder(bool value) -> MoreLinq.Experimental.AwaitQueryOptions!
MoreLinq.Experimental.AwaitQueryOptions.WithScheduler(System.Threading.Tasks.TaskScheduler! value) -> MoreLinq.Experimental.AwaitQueryOptions!
MoreLinq.Experimental.ExperimentalEnumerable
MoreLinq.Experimental.IAwaitQuery<T>
MoreLinq.Experimental.IAwaitQuery<T>.Options.get -> MoreLinq.Experimental.AwaitQueryOptions!
MoreLinq.Experimental.IAwaitQuery<T>.WithOptions(MoreLinq.Experimental.AwaitQueryOptions! options) -> MoreLinq.Experimental.IAwaitQuery<T>!
MoreLinq.Extensions.AcquireExtension
MoreLinq.Extensions.AggregateExtension
MoreLinq.Extensions.AggregateRightExtension
MoreLinq.Extensions.AppendExtension
MoreLinq.Extensions.AssertCountExtension
MoreLinq.Extensions.AssertExtension
MoreLinq.Extensions.AtLeastExtension
MoreLinq.Extensions.AtMostExtension
MoreLinq.Extensions.BacksertExtension
MoreLinq.Extensions.BatchExtension
MoreLinq.Extensions.CartesianExtension
MoreLinq.Extensions.ChooseExtension
MoreLinq.Extensions.CompareCountExtension
MoreLinq.Extensions.ConsumeExtension
MoreLinq.Extensions.CountBetweenExtension
MoreLinq.Extensions.CountByExtension
MoreLinq.Extensions.CountDownExtension
MoreLinq.Extensions.DistinctByExtension
MoreLinq.Extensions.DuplicatesExtension
MoreLinq.Extensions.EndsWithExtension
MoreLinq.Extensions.EquiZipExtension
MoreLinq.Extensions.EvaluateExtension
MoreLinq.Extensions.ExactlyExtension
MoreLinq.Extensions.ExceptByExtension
MoreLinq.Extensions.ExcludeExtension
MoreLinq.Extensions.FallbackIfEmptyExtension
MoreLinq.Extensions.FillBackwardExtension
MoreLinq.Extensions.FillForwardExtension
MoreLinq.Extensions.FirstExtension
MoreLinq.Extensions.FirstOrDefaultExtension
MoreLinq.Extensions.FlattenExtension
MoreLinq.Extensions.FoldExtension
MoreLinq.Extensions.ForEachExtension
MoreLinq.Extensions.FullGroupJoinExtension
MoreLinq.Extensions.FullJoinExtension
MoreLinq.Extensions.GroupAdjacentExtension
MoreLinq.Extensions.IndexByExtension
MoreLinq.Extensions.IndexExtension
MoreLinq.Extensions.InsertExtension
MoreLinq.Extensions.InterleaveExtension
MoreLinq.Extensions.LagExtension
MoreLinq.Extensions.LastExtension
MoreLinq.Extensions.LastOrDefaultExtension
MoreLinq.Extensions.LeadExtension
MoreLinq.Extensions.LeftJoinExtension
MoreLinq.Extensions.MaxByExtension
MoreLinq.Extensions.MaximaExtension
MoreLinq.Extensions.MinByExtension
MoreLinq.Extensions.MinimaExtension
MoreLinq.Extensions.MoveExtension
MoreLinq.Extensions.OrderByExtension
MoreLinq.Extensions.OrderedMergeExtension
MoreLinq.Extensions.PadExtension
MoreLinq.Extensions.PadStartExtension
MoreLinq.Extensions.PairwiseExtension
MoreLinq.Extensions.PartialSortByExtension
MoreLinq.Extensions.PartialSortExtension
MoreLinq.Extensions.PartitionExtension
MoreLinq.Extensions.PermutationsExtension
MoreLinq.Extensions.PipeExtension
MoreLinq.Extensions.PrependExtension
MoreLinq.Extensions.PreScanExtension
MoreLinq.Extensions.RandomSubsetExtension
MoreLinq.Extensions.RankByExtension
MoreLinq.Extensions.RankExtension
MoreLinq.Extensions.RepeatExtension
MoreLinq.Extensions.RightJoinExtension
MoreLinq.Extensions.RunLengthEncodeExtension
MoreLinq.Extensions.ScanByExtension
MoreLinq.Extensions.ScanExtension
MoreLinq.Extensions.ScanRightExtension
MoreLinq.Extensions.SegmentExtension
MoreLinq.Extensions.ShuffleExtension
MoreLinq.Extensions.SingleExtension
MoreLinq.Extensions.SingleOrDefaultExtension
MoreLinq.Extensions.SkipLastExtension
MoreLinq.Extensions.SkipUntilExtension
MoreLinq.Extensions.SliceExtension
MoreLinq.Extensions.SortedMergeExtension
MoreLinq.Extensions.SplitExtension
MoreLinq.Extensions.StartsWithExtension
MoreLinq.Extensions.SubsetsExtension
MoreLinq.Extensions.TagFirstLastExtension
MoreLinq.Extensions.TakeEveryExtension
MoreLinq.Extensions.TakeLastExtension
MoreLinq.Extensions.TakeUntilExtension
MoreLinq.Extensions.ThenByExtension
MoreLinq.Extensions.ToArrayByIndexExtension
MoreLinq.Extensions.ToDataTableExtension
MoreLinq.Extensions.ToDelimitedStringExtension
MoreLinq.Extensions.ToDictionaryExtension
MoreLinq.Extensions.ToHashSetExtension
MoreLinq.Extensions.ToLookupExtension
MoreLinq.Extensions.TraceExtension
MoreLinq.Extensions.TransposeExtension
MoreLinq.Extensions.WindowExtension
MoreLinq.Extensions.WindowLeftExtension
MoreLinq.Extensions.WindowRightExtension
MoreLinq.Extensions.ZipLongestExtension
MoreLinq.Extensions.ZipShortestExtension
MoreLinq.IExtremaEnumerable<T>
MoreLinq.IExtremaEnumerable<T>.Take(int count) -> System.Collections.Generic.IEnumerable<T>!
MoreLinq.IExtremaEnumerable<T>.TakeLast(int count) -> System.Collections.Generic.IEnumerable<T>!
MoreLinq.MoreEnumerable
MoreLinq.OrderByDirection
MoreLinq.OrderByDirection.Ascending = 0 -> MoreLinq.OrderByDirection
MoreLinq.OrderByDirection.Descending = 1 -> MoreLinq.OrderByDirection
MoreLinq.SequenceException
MoreLinq.SequenceException.SequenceException() -> void
MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void
MoreLinq.SequenceException.SequenceException(string? message) -> void
MoreLinq.SequenceException.SequenceException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void
static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<TResult1, TResult2, TResult>! resultSelector) -> TResult
static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult3, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<System.IObservable<T>!, System.IObservable<TResult3>!>! accumulator3, System.Func<TResult1, TResult2, TResult3, TResult>! resultSelector) -> TResult
static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<System.IObservable<T>!, System.IObservable<TResult3>!>! accumulator3, System.Func<System.IObservable<T>!, System.IObservable<TResult4>!>! accumulator4, System.Func<TResult1, TResult2, TResult3, TResult4, TResult>! resultSelector) -> TResult
static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<System.IObservable<T>!, System.IObservable<TResult3>!>! accumulator3, System.Func<System.IObservable<T>!, System.IObservable<TResult4>!>! accumulator4, System.Func<System.IObservable<T>!, System.IObservable<TResult5>!>! accumulator5, System.Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult>! resultSelector) -> TResult
static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<System.IObservable<T>!, System.IObservable<TResult3>!>! accumulator3, System.Func<System.IObservable<T>!, System.IObservable<TResult4>!>! accumulator4, System.Func<System.IObservable<T>!, System.IObservable<TResult5>!>! accumulator5, System.Func<System.IObservable<T>!, System.IObservable<TResult6>!>! accumulator6, System.Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult>! resultSelector) -> TResult
static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<System.IObservable<T>!, System.IObservable<TResult3>!>! accumulator3, System.Func<System.IObservable<T>!, System.IObservable<TResult4>!>! accumulator4, System.Func<System.IObservable<T>!, System.IObservable<TResult5>!>! accumulator5, System.Func<System.IObservable<T>!, System.IObservable<TResult6>!>! accumulator6, System.Func<System.IObservable<T>!, System.IObservable<TResult7>!>! accumulator7, System.Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult>! resultSelector) -> TResult
static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate<T, TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<System.IObservable<T>!, System.IObservable<TResult1>!>! accumulator1, System.Func<System.IObservable<T>!, System.IObservable<TResult2>!>! accumulator2, System.Func<System.IObservable<T>!, System.IObservable<TResult3>!>! accumulator3, System.Func<System.IObservable<T>!, System.IObservable<TResult4>!>! accumulator4, System.Func<System.IObservable<T>!, System.IObservable<TResult5>!>! accumulator5, System.Func<System.IObservable<T>!, System.IObservable<TResult6>!>! accumulator6, System.Func<System.IObservable<T>!, System.IObservable<TResult7>!>! accumulator7, System.Func<System.IObservable<T>!, System.IObservable<TResult8>!>! accumulator8, System.Func<TResult1, TResult2, TResult3, TResult4, TResult5, TResult6, TResult7, TResult8, TResult>! resultSelector) -> TResult
static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source) -> MoreLinq.Experimental.IAwaitQuery<T>!
static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source) -> MoreLinq.Experimental.IAwaitQuery<T>!
static MoreLinq.Experimental.ExperimentalEnumerable.Await<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, System.Threading.CancellationToken, System.Threading.Tasks.Task<TResult>!>! evaluator) -> MoreLinq.Experimental.IAwaitQuery<TResult>!
static MoreLinq.Experimental.ExperimentalEnumerable.Await<T>(this System.Collections.Generic.IEnumerable<System.Threading.Tasks.Task<T>!>! source) -> MoreLinq.Experimental.IAwaitQuery<T>!
static MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion<T, TTaskResult, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, System.Threading.CancellationToken, System.Threading.Tasks.Task<TTaskResult>!>! evaluator, System.Func<T, System.Threading.Tasks.Task<TTaskResult>!, TResult>! resultSelector) -> MoreLinq.Experimental.IAwaitQuery<TResult>!
static MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source, int value) -> MoreLinq.Experimental.IAwaitQuery<T>!
static MoreLinq.Experimental.ExperimentalEnumerable.Memoize<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source, bool value) -> MoreLinq.Experimental.IAwaitQuery<T>!
static MoreLinq.Experimental.ExperimentalEnumerable.Scheduler<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source, System.Threading.Tasks.TaskScheduler! value) -> MoreLinq.Experimental.IAwaitQuery<T>!
static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle<T, TCardinality, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TCardinality zero, TCardinality one, TCardinality many, System.Func<TCardinality, T?, TResult>! resultSelector) -> TResult
static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle<T, TCardinality>(this System.Collections.Generic.IEnumerable<T>! source, TCardinality zero, TCardinality one, TCardinality many) -> (TCardinality Cardinality, T? Value)
static MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency<T>(this MoreLinq.Experimental.IAwaitQuery<T>! source) -> MoreLinq.Experimental.IAwaitQuery<T>!
static MoreLinq.Extensions.AcquireExtension.Acquire<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> TSource[]!
static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, TAccumulate7 seed7, System.Func<TAccumulate7, T, TAccumulate7>! accumulator7, TAccumulate8 seed8, System.Func<TAccumulate8, T, TAccumulate8>! accumulator8, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, TAccumulate7 seed7, System.Func<TAccumulate7, T, TAccumulate7>! accumulator7, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.AggregateExtension.Aggregate<T, TAccumulate1, TAccumulate2, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, System.Func<TAccumulate1, TAccumulate2, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.AggregateRightExtension.AggregateRight<TSource, TAccumulate, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func, System.Func<TAccumulate, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.AggregateRightExtension.AggregateRight<TSource, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func) -> TAccumulate
static MoreLinq.Extensions.AggregateRightExtension.AggregateRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! func) -> TSource
static MoreLinq.Extensions.AppendExtension.Append<T>(this System.Collections.Generic.IEnumerable<T>! head, T tail) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.AssertCountExtension.AssertCount<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<int, int, System.Exception!>! errorSelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.AssertCountExtension.AssertCount<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.AssertExtension.Assert<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate, System.Func<TSource, System.Exception!>? errorSelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.AssertExtension.Assert<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.AtLeastExtension.AtLeast<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
static MoreLinq.Extensions.AtMostExtension.AtMost<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
static MoreLinq.Extensions.BacksertExtension.Backsert<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, int index) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.BatchExtension.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, System.Func<TSource[]!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.BatchExtension.Batch<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<TSource[]!>!
static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Collections.Generic.IEnumerable<T8>! eighth, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6, T7, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Func<T1, T2, T3, T4, T5, T6, T7, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, T6, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Func<T1, T2, T3, T4, T5, T6, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, T5, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Func<T1, T2, T3, T4, T5, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1, T2, T3, T4, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1, T2, T3, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.CartesianExtension.Cartesian<T1, T2, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Func<T1, T2, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.ChooseExtension.Choose<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, (bool, TResult)>! chooser) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.CompareCountExtension.CompareCount<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> int
static MoreLinq.Extensions.ConsumeExtension.Consume<T>(this System.Collections.Generic.IEnumerable<T>! source) -> void
static MoreLinq.Extensions.CountBetweenExtension.CountBetween<T>(this System.Collections.Generic.IEnumerable<T>! source, int min, int max) -> bool
static MoreLinq.Extensions.CountByExtension.CountBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
static MoreLinq.Extensions.CountByExtension.CountBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
static MoreLinq.Extensions.CountDownExtension.CountDown<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Func<T, int?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.DistinctByExtension.DistinctBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.DistinctByExtension.DistinctBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.DuplicatesExtension.Duplicates<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.DuplicatesExtension.Duplicates<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.EndsWithExtension.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IEqualityComparer<T>? comparer) -> bool
static MoreLinq.Extensions.EndsWithExtension.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
static MoreLinq.Extensions.EquiZipExtension.EquiZip<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1, T2, T3, T4, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.EquiZipExtension.EquiZip<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1, T2, T3, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.EquiZipExtension.EquiZip<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TSecond, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.EvaluateExtension.Evaluate<T>(this System.Collections.Generic.IEnumerable<System.Func<T>!>! functions) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.ExactlyExtension.Exactly<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
static MoreLinq.Extensions.ExceptByExtension.ExceptBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? keyComparer) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.ExceptByExtension.ExceptBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.ExcludeExtension.Exclude<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Collections.Generic.IEnumerable<T>! fallback) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.FillBackwardExtension.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.FillBackwardExtension.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.FillBackwardExtension.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.FillForwardExtension.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.FillForwardExtension.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.FillForwardExtension.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.FirstExtension.First<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T
static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T?
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, TResult>! folder) -> TResult
static MoreLinq.Extensions.FoldExtension.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TResult>! folder) -> TResult
static MoreLinq.Extensions.ForEachExtension.ForEach<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Action<T, int>! action) -> void
static MoreLinq.Extensions.ForEachExtension.ForEach<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Action<T>! action) -> void
static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TFirst>!, System.Collections.Generic.IEnumerable<TSecond>!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TFirst>!, System.Collections.Generic.IEnumerable<TSecond>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin<TFirst, TSecond, TKey>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable<TFirst>! First, System.Collections.Generic.IEnumerable<TSecond>! Second)>!
static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin<TFirst, TSecond, TKey>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable<TFirst>! First, System.Collections.Generic.IEnumerable<TSecond>! Second)>!
static MoreLinq.Extensions.FullJoinExtension.FullJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.FullJoinExtension.FullJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.FullJoinExtension.FullJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.FullJoinExtension.FullJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TElement>! elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!
static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TElement>! elementSelector) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!
static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>!>!
static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>!>!
static MoreLinq.Extensions.IndexByExtension.IndexBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
static MoreLinq.Extensions.IndexByExtension.IndexBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
static MoreLinq.Extensions.IndexExtension.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int startIndex) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
static MoreLinq.Extensions.IndexExtension.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
static MoreLinq.Extensions.InsertExtension.Insert<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, int index) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.InterleaveExtension.Interleave<T>(this System.Collections.Generic.IEnumerable<T>! sequence, params System.Collections.Generic.IEnumerable<T>![]! otherSequences) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.LagExtension.Lag<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.LagExtension.Lag<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLagValue, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.LastExtension.Last<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T
static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T?
static MoreLinq.Extensions.LeadExtension.Lead<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.LeadExtension.Lead<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLeadValue, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.LeftJoinExtension.LeftJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.LeftJoinExtension.LeftJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.LeftJoinExtension.LeftJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TSource, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.LeftJoinExtension.LeftJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TSource, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.MaxByExtension.MaxBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.Extensions.MaxByExtension.MaxBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.Extensions.MaximaExtension.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.Extensions.MaximaExtension.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.Extensions.MinByExtension.MinBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.Extensions.MinByExtension.MinBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.Extensions.MinimaExtension.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.Extensions.MinimaExtension.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.Extensions.MoveExtension.Move<T>(this System.Collections.Generic.IEnumerable<T>! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.OrderByExtension.OrderBy<T, TKey>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TKey>! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
static MoreLinq.Extensions.OrderByExtension.OrderBy<T, TKey>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<T, TKey, TResult>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Func<T, TKey>! keySelector, System.Func<T, TResult>! firstSelector, System.Func<T, TResult>! secondSelector, System.Func<T, T, TResult>! bothSelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<T, TKey, TResult>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Func<T, TKey>! keySelector, System.Func<T, TResult>! firstSelector, System.Func<T, TResult>! secondSelector, System.Func<T, T, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<T, TKey>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Func<T, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.PadExtension.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, System.Func<int, TSource>! paddingSelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.PadExtension.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.PadExtension.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
static MoreLinq.Extensions.PadStartExtension.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, System.Func<int, TSource>! paddingSelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.PadStartExtension.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.PadStartExtension.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
static MoreLinq.Extensions.PairwiseExtension.Pairwise<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.PartialSortExtension.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.PartialSortExtension.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.PartialSortExtension.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.PartialSortExtension.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.PartitionExtension.Partition<T, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<bool, T>!>! source, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.PartitionExtension.Partition<T, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<bool?, T>!>! source, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.PartitionExtension.Partition<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.PartitionExtension.Partition<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> (System.Collections.Generic.IEnumerable<T>! True, System.Collections.Generic.IEnumerable<T>! False)
static MoreLinq.Extensions.PartitionExtension.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.PartitionExtension.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.PartitionExtension.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.PartitionExtension.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.PartitionExtension.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.PartitionExtension.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, TKey key3, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
static MoreLinq.Extensions.PermutationsExtension.Permutations<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
static MoreLinq.Extensions.PipeExtension.Pipe<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Action<T>! action) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.PrependExtension.Prepend<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource value) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.PreScanExtension.PreScan<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! transformation, TSource identity) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset<T>(this System.Collections.Generic.IEnumerable<T>! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset<T>(this System.Collections.Generic.IEnumerable<T>! source, int subsetSize) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.RankByExtension.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.Extensions.RankByExtension.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.Extensions.RankExtension.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.Extensions.RankExtension.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.Extensions.RepeatExtension.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int count) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.RepeatExtension.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.RightJoinExtension.RightJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.RightJoinExtension.RightJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.RightJoinExtension.RightJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.RightJoinExtension.RightJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence, System.Collections.Generic.IEqualityComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<T, int>>!
static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<T, int>>!
static MoreLinq.Extensions.ScanByExtension.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TState>! seedSelector, System.Func<TState, TKey, TSource, TState>! accumulator, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TState>>!
static MoreLinq.Extensions.ScanByExtension.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TState>! seedSelector, System.Func<TState, TKey, TSource, TState>! accumulator) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TState>>!
static MoreLinq.Extensions.ScanExtension.Scan<TSource, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, TState seed, System.Func<TState, TSource, TState>! transformation) -> System.Collections.Generic.IEnumerable<TState>!
static MoreLinq.Extensions.ScanExtension.Scan<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! transformation) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.ScanRightExtension.ScanRight<TSource, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func) -> System.Collections.Generic.IEnumerable<TAccumulate>!
static MoreLinq.Extensions.ScanRightExtension.ScanRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! func) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.SegmentExtension.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
static MoreLinq.Extensions.SegmentExtension.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
static MoreLinq.Extensions.SegmentExtension.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, int, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
static MoreLinq.Extensions.ShuffleExtension.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Random! rand) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.ShuffleExtension.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.SingleExtension.Single<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T
static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T?
static MoreLinq.Extensions.SkipLastExtension.SkipLast<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.SkipUntilExtension.SkipUntil<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.SliceExtension.Slice<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.Extensions.SortedMergeExtension.SortedMerge<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.SortedMergeExtension.SortedMerge<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer<TSource>? comparer, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.SplitExtension.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, int count, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.SplitExtension.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.SplitExtension.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, int count, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.SplitExtension.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>! comparer, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.SplitExtension.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer, int count, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.SplitExtension.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.SplitExtension.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
static MoreLinq.Extensions.SplitExtension.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
static MoreLinq.Extensions.SplitExtension.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
static MoreLinq.Extensions.SplitExtension.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
static MoreLinq.Extensions.SplitExtension.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
static MoreLinq.Extensions.SplitExtension.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
static MoreLinq.Extensions.StartsWithExtension.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IEqualityComparer<T>? comparer) -> bool
static MoreLinq.Extensions.StartsWithExtension.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
static MoreLinq.Extensions.SubsetsExtension.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
static MoreLinq.Extensions.SubsetsExtension.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool, bool, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.TakeEveryExtension.TakeEvery<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int step) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.TakeLastExtension.TakeLast<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.TakeUntilExtension.TakeUntil<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.ThenByExtension.ThenBy<T, TKey>(this System.Linq.IOrderedEnumerable<T>! source, System.Func<T, TKey>! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
static MoreLinq.Extensions.ThenByExtension.ThenBy<T, TKey>(this System.Linq.IOrderedEnumerable<T>! source, System.Func<T, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector, System.Func<T, int, TResult>! resultSelector) -> TResult[]!
static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector, System.Func<T, TResult>! resultSelector) -> TResult[]!
static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector, System.Func<T, int, TResult>! resultSelector) -> TResult[]!
static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector, System.Func<T, TResult>! resultSelector) -> TResult[]!
static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex<T>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector) -> T[]!
static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector) -> T[]!
static MoreLinq.Extensions.ToDataTableExtension.ToDataTable<T, TTable>(this System.Collections.Generic.IEnumerable<T>! source, TTable! table, params System.Linq.Expressions.Expression<System.Func<T, object?>!>![]! expressions) -> TTable!
static MoreLinq.Extensions.ToDataTableExtension.ToDataTable<T, TTable>(this System.Collections.Generic.IEnumerable<T>! source, TTable! table) -> TTable!
static MoreLinq.Extensions.ToDataTableExtension.ToDataTable<T>(this System.Collections.Generic.IEnumerable<T>! source, params System.Linq.Expressions.Expression<System.Func<T, object?>!>![]! expressions) -> System.Data.DataTable!
static MoreLinq.Extensions.ToDataTableExtension.ToDataTable<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Data.DataTable!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<bool>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<byte>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<char>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<decimal>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<double>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<float>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<int>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<long>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<sbyte>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<short>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<string!>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<uint>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<ulong>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable<ushort>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, string! delimiter) -> string!
static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.Dictionary<TKey, TValue>!
static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.Dictionary<TKey, TValue>!
static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
static MoreLinq.Extensions.ToHashSetExtension.ToHashSet<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.HashSet<TSource>!
static MoreLinq.Extensions.ToHashSetExtension.ToHashSet<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
static MoreLinq.Extensions.ToLookupExtension.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Linq.ILookup<TKey, TValue>!
static MoreLinq.Extensions.ToLookupExtension.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup<TKey, TValue>!
static MoreLinq.Extensions.ToLookupExtension.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Linq.ILookup<TKey, TValue>!
static MoreLinq.Extensions.ToLookupExtension.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Linq.ILookup<TKey, TValue>!
static MoreLinq.Extensions.TraceExtension.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, string? format) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.TraceExtension.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, string!>! formatter) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.TraceExtension.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.Extensions.TransposeExtension.Transpose<T>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>! source) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
static MoreLinq.Extensions.WindowExtension.Window<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
static MoreLinq.Extensions.WindowLeftExtension.WindowLeft<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
static MoreLinq.Extensions.WindowRightExtension.WindowRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1?, T2?, T3?, T4?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1?, T2?, T3?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.ZipLongestExtension.ZipLongest<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst?, TSecond?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1, T2, T3, T4, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1, T2, T3, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.Extensions.ZipShortestExtension.ZipShortest<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TSecond, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Acquire<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> TSource[]!
static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, TAccumulate7 seed7, System.Func<TAccumulate7, T, TAccumulate7>! accumulator7, TAccumulate8 seed8, System.Func<TAccumulate8, T, TAccumulate8>! accumulator8, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TAccumulate8, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, TAccumulate7 seed7, System.Func<TAccumulate7, T, TAccumulate7>! accumulator7, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TAccumulate7, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, TAccumulate6 seed6, System.Func<TAccumulate6, T, TAccumulate6>! accumulator6, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TAccumulate6, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, TAccumulate5 seed5, System.Func<TAccumulate5, T, TAccumulate5>! accumulator5, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TAccumulate5, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, TAccumulate4 seed4, System.Func<TAccumulate4, T, TAccumulate4>! accumulator4, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TAccumulate4, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TAccumulate3, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, TAccumulate3 seed3, System.Func<TAccumulate3, T, TAccumulate3>! accumulator3, System.Func<TAccumulate1, TAccumulate2, TAccumulate3, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Aggregate<T, TAccumulate1, TAccumulate2, TResult>(this System.Collections.Generic.IEnumerable<T>! source, TAccumulate1 seed1, System.Func<TAccumulate1, T, TAccumulate1>! accumulator1, TAccumulate2 seed2, System.Func<TAccumulate2, T, TAccumulate2>! accumulator2, System.Func<TAccumulate1, TAccumulate2, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.AggregateRight<TSource, TAccumulate, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func, System.Func<TAccumulate, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.AggregateRight<TSource, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func) -> TAccumulate
static MoreLinq.MoreEnumerable.AggregateRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! func) -> TSource
static MoreLinq.MoreEnumerable.Append<T>(System.Collections.Generic.IEnumerable<T>! head, T tail) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.Assert<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate, System.Func<TSource, System.Exception!>? errorSelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Assert<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.AssertCount<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<int, int, System.Exception!>! errorSelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.AssertCount<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.AtLeast<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
static MoreLinq.MoreEnumerable.AtMost<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
static MoreLinq.MoreEnumerable.Backsert<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, int index) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.Batch<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int size, System.Func<TSource[]!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Batch<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<TSource[]!>!
static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Collections.Generic.IEnumerable<T8>! eighth, System.Func<T1, T2, T3, T4, T5, T6, T7, T8, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, T7, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Collections.Generic.IEnumerable<T7>! seventh, System.Func<T1, T2, T3, T4, T5, T6, T7, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, T6, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Collections.Generic.IEnumerable<T6>! sixth, System.Func<T1, T2, T3, T4, T5, T6, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, T5, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Collections.Generic.IEnumerable<T5>! fifth, System.Func<T1, T2, T3, T4, T5, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1, T2, T3, T4, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Cartesian<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1, T2, T3, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Cartesian<T1, T2, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Func<T1, T2, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Choose<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, (bool, TResult)>! chooser) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.CompareCount<TFirst, TSecond>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second) -> int
static MoreLinq.MoreEnumerable.Consume<T>(this System.Collections.Generic.IEnumerable<T>! source) -> void
static MoreLinq.MoreEnumerable.CountBetween<T>(this System.Collections.Generic.IEnumerable<T>! source, int min, int max) -> bool
static MoreLinq.MoreEnumerable.CountBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
static MoreLinq.MoreEnumerable.CountBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, int>>!
static MoreLinq.MoreEnumerable.CountDown<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Func<T, int?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.DistinctBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.DistinctBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Duplicates<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Duplicates<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IEqualityComparer<T>? comparer) -> bool
static MoreLinq.MoreEnumerable.EndsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
static MoreLinq.MoreEnumerable.EquiZip<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1, T2, T3, T4, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.EquiZip<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1, T2, T3, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.EquiZip<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TSecond, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Evaluate<T>(this System.Collections.Generic.IEnumerable<System.Func<T>!>! functions) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.Exactly<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> bool
static MoreLinq.MoreEnumerable.ExceptBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? keyComparer) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.ExceptBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Exclude<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Collections.Generic.IEnumerable<T>! fallback) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.FallbackIfEmpty<T>(this System.Collections.Generic.IEnumerable<T>! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.FillBackward<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<T, T, T>! fillSelector) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.FillForward<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.First<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T
static MoreLinq.MoreEnumerable.FirstOrDefault<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T?
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.Fold<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TResult>! folder) -> TResult
static MoreLinq.MoreEnumerable.ForEach<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Action<T, int>! action) -> void
static MoreLinq.MoreEnumerable.ForEach<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Action<T>! action) -> void
static MoreLinq.MoreEnumerable.From<T>(params System.Func<T>![]! functions) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.From<T>(System.Func<T>! function) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.From<T>(System.Func<T>! function1, System.Func<T>! function2, System.Func<T>! function3) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.From<T>(System.Func<T>! function1, System.Func<T>! function2) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.FullGroupJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TFirst>!, System.Collections.Generic.IEnumerable<TSecond>!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.FullGroupJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TFirst>!, System.Collections.Generic.IEnumerable<TSecond>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.FullGroupJoin<TFirst, TSecond, TKey>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable<TFirst>! First, System.Collections.Generic.IEnumerable<TSecond>! Second)>!
static MoreLinq.MoreEnumerable.FullGroupJoin<TFirst, TSecond, TKey>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable<TFirst>! First, System.Collections.Generic.IEnumerable<TSecond>! Second)>!
static MoreLinq.MoreEnumerable.FullJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.FullJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.FullJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.FullJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Generate<TResult>(TResult initial, System.Func<TResult, TResult>! generator) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.GenerateByIndex<TResult>(System.Func<int, TResult>! generator) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.GroupAdjacent<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TElement>! elementSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!
static MoreLinq.MoreEnumerable.GroupAdjacent<TSource, TKey, TElement>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TElement>! elementSelector) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!
static MoreLinq.MoreEnumerable.GroupAdjacent<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.GroupAdjacent<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.GroupAdjacent<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>!>!
static MoreLinq.MoreEnumerable.GroupAdjacent<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TSource>!>!
static MoreLinq.MoreEnumerable.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int startIndex) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
static MoreLinq.MoreEnumerable.Index<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
static MoreLinq.MoreEnumerable.IndexBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
static MoreLinq.MoreEnumerable.IndexBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<int, TSource>>!
static MoreLinq.MoreEnumerable.Insert<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, int index) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.Interleave<T>(this System.Collections.Generic.IEnumerable<T>! sequence, params System.Collections.Generic.IEnumerable<T>![]! otherSequences) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.Lag<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Lag<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLagValue, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Last<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T
static MoreLinq.MoreEnumerable.LastOrDefault<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T?
static MoreLinq.MoreEnumerable.Lead<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, System.Func<TSource, TSource?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Lead<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, int offset, TSource defaultLeadValue, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.LeftJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.LeftJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.LeftJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TSource, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.LeftJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! firstSelector, System.Func<TSource, TSource, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.MaxBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.MoreEnumerable.MaxBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Maxima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.MoreEnumerable.MinBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.MoreEnumerable.MinBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector, System.Collections.Generic.IComparer<TKey>? comparer) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Minima<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! selector) -> MoreLinq.IExtremaEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Move<T>(this System.Collections.Generic.IEnumerable<T>! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.OrderBy<T, TKey>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TKey>! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
static MoreLinq.MoreEnumerable.OrderBy<T, TKey>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
static MoreLinq.MoreEnumerable.OrderedMerge<T, TKey, TResult>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Func<T, TKey>! keySelector, System.Func<T, TResult>! firstSelector, System.Func<T, TResult>! secondSelector, System.Func<T, T, TResult>! bothSelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.OrderedMerge<T, TKey, TResult>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Func<T, TKey>! keySelector, System.Func<T, TResult>! firstSelector, System.Func<T, TResult>! secondSelector, System.Func<T, T, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.OrderedMerge<T, TKey>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Func<T, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.OrderedMerge<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.OrderedMerge<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.OrderedMerge<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.OrderedMerge<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TFirst, TResult>! firstSelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, System.Func<int, TSource>! paddingSelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Pad<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
static MoreLinq.MoreEnumerable.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, System.Func<int, TSource>! paddingSelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.PadStart<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int width) -> System.Collections.Generic.IEnumerable<TSource?>!
static MoreLinq.MoreEnumerable.Pairwise<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count, System.Collections.Generic.IComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.PartialSort<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.PartialSortBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, int count, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Partition<T, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<bool, T>!>! source, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Partition<T, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<bool?, T>!>! source, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Partition<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate, System.Func<System.Collections.Generic.IEnumerable<T>!, System.Collections.Generic.IEnumerable<T>!, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Partition<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! predicate) -> (System.Collections.Generic.IEnumerable<T>! True, System.Collections.Generic.IEnumerable<T>! False)
static MoreLinq.MoreEnumerable.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer<TKey>? comparer, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Partition<TKey, TElement, TResult>(this System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>! source, TKey key1, TKey key2, TKey key3, System.Func<System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<TElement>!, System.Collections.Generic.IEnumerable<System.Linq.IGrouping<TKey, TElement>!>!, TResult>! resultSelector) -> TResult
static MoreLinq.MoreEnumerable.Permutations<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
static MoreLinq.MoreEnumerable.Pipe<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Action<T>! action) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.Prepend<TSource>(System.Collections.Generic.IEnumerable<TSource>! source, TSource value) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.PreScan<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! transformation, TSource identity) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable<double>!
static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable<double>!
static MoreLinq.MoreEnumerable.RandomSubset<T>(this System.Collections.Generic.IEnumerable<T>! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.RandomSubset<T>(this System.Collections.Generic.IEnumerable<T>! source, int subsetSize) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.MoreEnumerable.Rank<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.MoreEnumerable.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.MoreEnumerable.RankBy<TSource, TKey>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.MoreEnumerable.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int count) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.Repeat<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.Return<T>(T item) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.RightJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.RightJoin<TFirst, TSecond, TKey, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TKey>! firstKeySelector, System.Func<TSecond, TKey>! secondKeySelector, System.Func<TSecond, TResult>! secondSelector, System.Func<TFirst, TSecond, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.RightJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.RightJoin<TSource, TKey, TResult>(this System.Collections.Generic.IEnumerable<TSource>! first, System.Collections.Generic.IEnumerable<TSource>! second, System.Func<TSource, TKey>! keySelector, System.Func<TSource, TResult>! secondSelector, System.Func<TSource, TSource, TResult>! bothSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence, System.Collections.Generic.IEqualityComparer<T>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<T, int>>!
static MoreLinq.MoreEnumerable.RunLengthEncode<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<T, int>>!
static MoreLinq.MoreEnumerable.Scan<TSource, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, TState seed, System.Func<TState, TSource, TState>! transformation) -> System.Collections.Generic.IEnumerable<TState>!
static MoreLinq.MoreEnumerable.Scan<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! transformation) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TState>! seedSelector, System.Func<TState, TKey, TSource, TState>! accumulator, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TState>>!
static MoreLinq.MoreEnumerable.ScanBy<TSource, TKey, TState>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TKey>! keySelector, System.Func<TKey, TState>! seedSelector, System.Func<TState, TKey, TSource, TState>! accumulator) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TState>>!
static MoreLinq.MoreEnumerable.ScanRight<TSource, TAccumulate>(this System.Collections.Generic.IEnumerable<TSource>! source, TAccumulate seed, System.Func<TSource, TAccumulate, TAccumulate>! func) -> System.Collections.Generic.IEnumerable<TAccumulate>!
static MoreLinq.MoreEnumerable.ScanRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, TSource, TSource>! func) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
static MoreLinq.MoreEnumerable.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
static MoreLinq.MoreEnumerable.Segment<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, T, int, bool>! newSegmentPredicate) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable<int>!
static MoreLinq.MoreEnumerable.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Random! rand) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.Shuffle<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.Single<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T
static MoreLinq.MoreEnumerable.SingleOrDefault<T>(this MoreLinq.IExtremaEnumerable<T>! source) -> T?
static MoreLinq.MoreEnumerable.SkipLast<T>(this System.Collections.Generic.IEnumerable<T>! source, int count) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.SkipUntil<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Slice<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.SortedMerge<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.SortedMerge<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer<TSource>? comparer, params System.Collections.Generic.IEnumerable<TSource>![]! otherSequences) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, int count, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, int count, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>! comparer, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer, int count, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Split<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Func<System.Collections.Generic.IEnumerable<TSource>!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
static MoreLinq.MoreEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! separatorFunc) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
static MoreLinq.MoreEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
static MoreLinq.MoreEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer, int count) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
static MoreLinq.MoreEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
static MoreLinq.MoreEnumerable.Split<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, TSource separator) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<TSource>!>!
static MoreLinq.MoreEnumerable.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second, System.Collections.Generic.IEqualityComparer<T>? comparer) -> bool
static MoreLinq.MoreEnumerable.StartsWith<T>(this System.Collections.Generic.IEnumerable<T>! first, System.Collections.Generic.IEnumerable<T>! second) -> bool
static MoreLinq.MoreEnumerable.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
static MoreLinq.MoreEnumerable.Subsets<T>(this System.Collections.Generic.IEnumerable<T>! sequence) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<T>!>!
static MoreLinq.MoreEnumerable.TagFirstLast<TSource, TResult>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool, bool, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.TakeEvery<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int step) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.TakeLast<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int count) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.TakeUntil<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, bool>! predicate) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.ThenBy<T, TKey>(this System.Linq.IOrderedEnumerable<T>! source, System.Func<T, TKey>! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
static MoreLinq.MoreEnumerable.ThenBy<T, TKey>(this System.Linq.IOrderedEnumerable<T>! source, System.Func<T, TKey>! keySelector, System.Collections.Generic.IComparer<TKey>? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable<T>!
static MoreLinq.MoreEnumerable.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector, System.Func<T, int, TResult>! resultSelector) -> TResult[]!
static MoreLinq.MoreEnumerable.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector, System.Func<T, TResult>! resultSelector) -> TResult[]!
static MoreLinq.MoreEnumerable.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector, System.Func<T, int, TResult>! resultSelector) -> TResult[]!
static MoreLinq.MoreEnumerable.ToArrayByIndex<T, TResult>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector, System.Func<T, TResult>! resultSelector) -> TResult[]!
static MoreLinq.MoreEnumerable.ToArrayByIndex<T>(this System.Collections.Generic.IEnumerable<T>! source, int length, System.Func<T, int>! indexSelector) -> T[]!
static MoreLinq.MoreEnumerable.ToArrayByIndex<T>(this System.Collections.Generic.IEnumerable<T>! source, System.Func<T, int>! indexSelector) -> T[]!
static MoreLinq.MoreEnumerable.ToDataTable<T, TTable>(this System.Collections.Generic.IEnumerable<T>! source, TTable! table, params System.Linq.Expressions.Expression<System.Func<T, object?>!>![]! expressions) -> TTable!
static MoreLinq.MoreEnumerable.ToDataTable<T, TTable>(this System.Collections.Generic.IEnumerable<T>! source, TTable! table) -> TTable!
static MoreLinq.MoreEnumerable.ToDataTable<T>(this System.Collections.Generic.IEnumerable<T>! source, params System.Linq.Expressions.Expression<System.Func<T, object?>!>![]! expressions) -> System.Data.DataTable!
static MoreLinq.MoreEnumerable.ToDataTable<T>(this System.Collections.Generic.IEnumerable<T>! source) -> System.Data.DataTable!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<bool>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<byte>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<char>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<decimal>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<double>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<float>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<int>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<long>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<sbyte>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<short>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<string!>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<uint>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<ulong>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable<ushort>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDelimitedString<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, string! delimiter) -> string!
static MoreLinq.MoreEnumerable.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.Dictionary<TKey, TValue>!
static MoreLinq.MoreEnumerable.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
static MoreLinq.MoreEnumerable.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Collections.Generic.Dictionary<TKey, TValue>!
static MoreLinq.MoreEnumerable.ToDictionary<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Collections.Generic.Dictionary<TKey, TValue>!
static MoreLinq.MoreEnumerable.ToHashSet<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Collections.Generic.IEqualityComparer<TSource>? comparer) -> System.Collections.Generic.HashSet<TSource>!
static MoreLinq.MoreEnumerable.ToHashSet<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.HashSet<TSource>!
static MoreLinq.MoreEnumerable.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Linq.ILookup<TKey, TValue>!
static MoreLinq.MoreEnumerable.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup<TKey, TValue>!
static MoreLinq.MoreEnumerable.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source, System.Collections.Generic.IEqualityComparer<TKey>? comparer) -> System.Linq.ILookup<TKey, TValue>!
static MoreLinq.MoreEnumerable.ToLookup<TKey, TValue>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey, TValue>>! source) -> System.Linq.ILookup<TKey, TValue>!
static MoreLinq.MoreEnumerable.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, string? format) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, System.Func<TSource, string!>! formatter) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Trace<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source) -> System.Collections.Generic.IEnumerable<TSource>!
static MoreLinq.MoreEnumerable.Transpose<T>(this System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>! source) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<T>!>!
static MoreLinq.MoreEnumerable.TraverseBreadthFirst<T>(T root, System.Func<T, System.Collections.Generic.IEnumerable<T>!>! childrenSelector) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.TraverseDepthFirst<T>(T root, System.Func<T, System.Collections.Generic.IEnumerable<T>!>! childrenSelector) -> System.Collections.Generic.IEnumerable<T>!
static MoreLinq.MoreEnumerable.Unfold<TState, T, TResult>(TState state, System.Func<TState, T>! generator, System.Func<T, bool>! predicate, System.Func<T, TState>! stateSelector, System.Func<T, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.Window<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
static MoreLinq.MoreEnumerable.WindowLeft<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
static MoreLinq.MoreEnumerable.WindowRight<TSource>(this System.Collections.Generic.IEnumerable<TSource>! source, int size) -> System.Collections.Generic.IEnumerable<System.Collections.Generic.IList<TSource>!>!
static MoreLinq.MoreEnumerable.ZipLongest<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1?, T2?, T3?, T4?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.ZipLongest<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1?, T2?, T3?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.ZipLongest<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst?, TSecond?, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.ZipShortest<T1, T2, T3, T4, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Collections.Generic.IEnumerable<T4>! fourth, System.Func<T1, T2, T3, T4, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.ZipShortest<T1, T2, T3, TResult>(this System.Collections.Generic.IEnumerable<T1>! first, System.Collections.Generic.IEnumerable<T2>! second, System.Collections.Generic.IEnumerable<T3>! third, System.Func<T1, T2, T3, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static MoreLinq.MoreEnumerable.ZipShortest<TFirst, TSecond, TResult>(this System.Collections.Generic.IEnumerable<TFirst>! first, System.Collections.Generic.IEnumerable<TSecond>! second, System.Func<TFirst, TSecond, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable<TResult>!
static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions!
