From 183723aa9b57b04ec2a40bac80debb8d41786043 Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Sat, 19 Nov 2022 17:24:48 -0600 Subject: [PATCH 001/157] Update "Memoize" documentation (#895) --- MoreLinq/Experimental/Memoize.cs | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/MoreLinq/Experimental/Memoize.cs b/MoreLinq/Experimental/Memoize.cs index da261b1a2..0888ae455 100644 --- a/MoreLinq/Experimental/Memoize.cs +++ b/MoreLinq/Experimental/Memoize.cs @@ -34,17 +34,21 @@ static partial class ExperimentalEnumerable /// Type of elements in . /// The source sequence. /// - /// Returns a sequence that corresponds to a cached version of the - /// input sequence. + /// Returns a sequence that corresponds to a cached version of the input + /// sequence. + /// + /// + /// is . + /// /// /// The returned will cache items from /// in a thread-safe manner. Each thread can /// call its to acquire an /// iterator but the same iterator should not be used simultanesouly - /// from multiple threads. The sequence supplied in - /// is not expected to be thread-safe but it - /// is required to be thread-agnostic because different threads - /// (though never simultaneously) may iterate over the sequence. + /// from multiple threads. The sequence supplied in is not expected to be thread-safe but it is required + /// to be thread-agnostic because different threads (though never + /// simultaneously) may iterate over the sequence. /// public static IEnumerable Memoize(this IEnumerable source) From c3a7094d196df0858f14ad3d000cb2c9a79c6198 Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Sat, 19 Nov 2022 18:23:30 -0600 Subject: [PATCH 002/157] Add parameter annotations for "Partition" (#897) --- MoreLinq/Partition.cs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/MoreLinq/Partition.cs b/MoreLinq/Partition.cs index 047c48c0f..2265f96ec 100644 --- a/MoreLinq/Partition.cs +++ b/MoreLinq/Partition.cs @@ -101,7 +101,7 @@ public static TResult Partition(this IEnumerable> Func, IEnumerable, TResult> resultSelector) { if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return source.Partition(true, false, (t, f, _) => resultSelector(t, f)); + return source.Partition(key1: true, key2: false, (t, f, _) => resultSelector(t, f)); } /// @@ -124,7 +124,7 @@ public static TResult Partition(this IEnumerable Func, IEnumerable, IEnumerable, TResult> resultSelector) { if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return source.Partition(true, false, null, (t, f, n, _) => resultSelector(t, f, n)); + return source.Partition(key1: true, key2: false, key3: null, (t, f, n, _) => resultSelector(t, f, n)); } /// @@ -149,7 +149,7 @@ public static TResult Partition(this IEnumerable public static TResult Partition(this IEnumerable> source, TKey key, Func, IEnumerable>, TResult> resultSelector) => - Partition(source, key, null, resultSelector); + Partition(source, key, comparer: null, resultSelector); /// /// Partitions a grouping and projects a result from group elements @@ -177,7 +177,7 @@ public static TResult Partition(this IEnumerable, IEnumerable>, TResult> resultSelector) { if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return PartitionImpl(source, 1, key, default!, default!, comparer, + return PartitionImpl(source, 1, key, key2: default!, key3: default!, comparer, (a, _, _, rest) => resultSelector(a, rest)); } @@ -205,7 +205,7 @@ public static TResult Partition(this IEnumerable(this IEnumerable> source, TKey key1, TKey key2, Func, IEnumerable, IEnumerable>, TResult> resultSelector) => - Partition(source, key1, key2, null, resultSelector); + Partition(source, key1, key2, comparer: null, resultSelector); /// /// Partitions a grouping and projects a result from elements of @@ -235,7 +235,7 @@ public static TResult Partition(this IEnumerable, IEnumerable, IEnumerable>, TResult> resultSelector) { if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return PartitionImpl(source, 2, key1, key2, default!, comparer, + return PartitionImpl(source, 2, key1, key2, key3: default!, comparer, (a, b, _, rest) => resultSelector(a, b, rest)); } @@ -264,7 +264,7 @@ public static TResult Partition(this IEnumerable(this IEnumerable> source, TKey key1, TKey key2, TKey key3, Func, IEnumerable, IEnumerable, IEnumerable>, TResult> resultSelector) => - Partition(source, key1, key2, key3, null, resultSelector); + Partition(source, key1, key2, key3, comparer: null, resultSelector); /// /// Partitions a grouping and projects a result from elements groups From a55baa75604638a5c4b4706b6f3377ee958cac79 Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Sun, 20 Nov 2022 04:43:27 -0600 Subject: [PATCH 003/157] Document "Partition" exceptions (#886) --- MoreLinq/Extensions.g.cs | 47 ++++++++++++++++++++++++++++++++++++---- MoreLinq/Partition.cs | 47 ++++++++++++++++++++++++++++++++++++---- 2 files changed, 86 insertions(+), 8 deletions(-) diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index 1a77a18e6..cbbb688ac 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -4154,6 +4154,8 @@ public static partial class PartitionExtension /// A tuple of elements satisfying the predicate and those that do not, /// respectively. /// + /// is + /// . /// /// True, IEnumerable False) /// /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, Func, IEnumerable, TResult> resultSelector) @@ -4201,6 +4207,10 @@ public static TResult Partition(this IEnumerable> /// /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, Func, IEnumerable, IEnumerable, TResult> resultSelector) @@ -4222,6 +4232,10 @@ public static TResult Partition(this IEnumerable /// /// The return value from . /// + /// + /// , , or + /// is . + /// /// /// (this IEnumerable source, /// matching a key and those groups that do not. /// /// Type of keys in source groupings. - /// Type of elements in source groupings. + /// Type of elements in source + /// groupings. /// Type of the result. /// The source sequence. /// The key to partition. /// /// Function that projects the result from sequences of elements - /// matching and those groups that do not (in - /// the order in which they appear in ), - /// passed as arguments. + /// matching and those groups that do not (in the + /// order in which they appear in ), passed as + /// arguments. /// /// /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, TKey key, @@ -4280,6 +4299,10 @@ public static TResult Partition(this IEnumerable /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, TKey key1, TKey key2, @@ -4305,6 +4328,10 @@ public static TResult Partition(this IEnumerable /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, TKey key, IEqualityComparer? comparer, @@ -4332,6 +4359,10 @@ public static TResult Partition(this IEnumerable /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, TKey key1, TKey key2, TKey key3, @@ -4359,6 +4390,10 @@ public static TResult Partition(this IEnumerable /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, TKey key1, TKey key2, IEqualityComparer? comparer, @@ -4388,6 +4423,10 @@ public static TResult Partition(this IEnumerable /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, TKey key1, TKey key2, TKey key3, IEqualityComparer? comparer, diff --git a/MoreLinq/Partition.cs b/MoreLinq/Partition.cs index 2265f96ec..ccd43f7f8 100644 --- a/MoreLinq/Partition.cs +++ b/MoreLinq/Partition.cs @@ -33,6 +33,8 @@ static partial class MoreEnumerable /// A tuple of elements satisfying the predicate and those that do not, /// respectively. /// + /// is + /// . /// /// True, IEnumerable False) /// /// The return value from . /// + /// + /// , , or + /// is . + /// /// /// (this IEnumerable source, /// /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, Func, IEnumerable, TResult> resultSelector) @@ -119,6 +129,10 @@ public static TResult Partition(this IEnumerable> /// /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, Func, IEnumerable, IEnumerable, TResult> resultSelector) @@ -132,19 +146,24 @@ public static TResult Partition(this IEnumerable /// matching a key and those groups that do not. /// /// Type of keys in source groupings. - /// Type of elements in source groupings. + /// Type of elements in source + /// groupings. /// Type of the result. /// The source sequence. /// The key to partition. /// /// Function that projects the result from sequences of elements - /// matching and those groups that do not (in - /// the order in which they appear in ), - /// passed as arguments. + /// matching and those groups that do not (in the + /// order in which they appear in ), passed as + /// arguments. /// /// /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, TKey key, @@ -171,6 +190,10 @@ public static TResult Partition(this IEnumerable /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, TKey key, IEqualityComparer? comparer, @@ -201,6 +224,10 @@ public static TResult Partition(this IEnumerable /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, TKey key1, TKey key2, @@ -229,6 +256,10 @@ public static TResult Partition(this IEnumerable /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, TKey key1, TKey key2, IEqualityComparer? comparer, @@ -260,6 +291,10 @@ public static TResult Partition(this IEnumerable /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, TKey key1, TKey key2, TKey key3, @@ -289,6 +324,10 @@ public static TResult Partition(this IEnumerable /// The return value from . /// + /// + /// or is + /// . + /// public static TResult Partition(this IEnumerable> source, TKey key1, TKey key2, TKey key3, IEqualityComparer? comparer, From 41a419559c6741845f4ed957c88b9bf72648c014 Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Sun, 20 Nov 2022 04:44:25 -0600 Subject: [PATCH 004/157] Add null-check for "Partition" result selector (#896) --- MoreLinq/Partition.cs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/MoreLinq/Partition.cs b/MoreLinq/Partition.cs index ccd43f7f8..68bc823a7 100644 --- a/MoreLinq/Partition.cs +++ b/MoreLinq/Partition.cs @@ -85,6 +85,8 @@ public static TResult Partition(this IEnumerable source, { if (source == null) throw new ArgumentNullException(nameof(source)); if (predicate == null) throw new ArgumentNullException(nameof(predicate)); + if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); + return source.GroupBy(predicate).Partition(resultSelector); } From 74a282a5ebb43cce2de5b6b466ea8dc9bf29dcaa Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Sun, 20 Nov 2022 04:51:37 -0600 Subject: [PATCH 005/157] Rewrite switch in "Memoize" as expression (#894) --- MoreLinq/Experimental/Memoize.cs | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/MoreLinq/Experimental/Memoize.cs b/MoreLinq/Experimental/Memoize.cs index 0888ae455..cc5e2a09a 100644 --- a/MoreLinq/Experimental/Memoize.cs +++ b/MoreLinq/Experimental/Memoize.cs @@ -51,17 +51,15 @@ static partial class ExperimentalEnumerable /// simultaneously) may iterate over the sequence. /// - public static IEnumerable Memoize(this IEnumerable source) - { - switch (source) + public static IEnumerable Memoize(this IEnumerable source) => + source switch { - case null: throw new ArgumentNullException(nameof(source)); - case ICollection : // ... - case IReadOnlyCollection: // ... - case MemoizedEnumerable : return source; - default: return new MemoizedEnumerable(source); - } - } + null => throw new ArgumentNullException(nameof(source)), + ICollection => source, + IReadOnlyCollection => source, + MemoizedEnumerable => source, + _ => new MemoizedEnumerable(source), + }; } sealed class MemoizedEnumerable : IEnumerable, IDisposable From 9ef27ea1b27d056c0ea92ee86e6e999decd1fae9 Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Wed, 23 Nov 2022 15:01:13 -0600 Subject: [PATCH 006/157] Clean-up internal "Partition" nullability (#881) --- MoreLinq.Test/PartitionTest.cs | 2 ++ MoreLinq/Partition.cs | 16 +++++++++------- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/MoreLinq.Test/PartitionTest.cs b/MoreLinq.Test/PartitionTest.cs index cdc4ac19c..2883885c1 100644 --- a/MoreLinq.Test/PartitionTest.cs +++ b/MoreLinq.Test/PartitionTest.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#nullable enable + namespace MoreLinq.Test { using System; diff --git a/MoreLinq/Partition.cs b/MoreLinq/Partition.cs index 68bc823a7..aa72f8725 100644 --- a/MoreLinq/Partition.cs +++ b/MoreLinq/Partition.cs @@ -202,7 +202,8 @@ public static TResult Partition(this IEnumerable, IEnumerable>, TResult> resultSelector) { if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return PartitionImpl(source, 1, key, key2: default!, key3: default!, comparer, + + return PartitionImpl(source, 1, key, key2: default, key3: default, comparer, (a, _, _, rest) => resultSelector(a, rest)); } @@ -268,8 +269,9 @@ public static TResult Partition(this IEnumerable, IEnumerable, IEnumerable>, TResult> resultSelector) { if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return PartitionImpl(source, 2, key1, key2, key3: default!, comparer, - (a, b, _, rest) => resultSelector(a, b, rest)); + + return PartitionImpl(source, 2, key1, key2, key3: default, comparer, + (a, b, c, rest) => resultSelector(a, b, rest)); } /// @@ -337,7 +339,7 @@ public static TResult Partition(this IEnumerable(IEnumerable> source, - int count, TKey key1, TKey key2, TKey key3, IEqualityComparer? comparer, + int count, TKey? key1, TKey? key2, TKey? key3, IEqualityComparer? comparer, Func, IEnumerable, IEnumerable, IEnumerable>, TResult> resultSelector) { Debug.Assert(count is > 0 and <= 3); @@ -358,9 +360,9 @@ static TResult PartitionImpl(IEnumerable 0 && comparer.Equals(e.Key, key1) ? 0 - : count > 1 && comparer.Equals(e.Key, key2) ? 1 - : count > 2 && comparer.Equals(e.Key, key3) ? 2 + var i = count > 0 && comparer.Equals(e.Key, key1!) ? 0 + : count > 1 && comparer.Equals(e.Key, key2!) ? 1 + : count > 2 && comparer.Equals(e.Key, key3!) ? 2 : -1; if (i < 0) From 34ce84af6cfeef3824ca4d9b4d93f80c50c1745c Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Wed, 30 Nov 2022 15:39:15 -0600 Subject: [PATCH 007/157] Add exceptions section to "Zip*" docs This is a squashed merge of PR #887. Co-authored-by: Atif Aziz --- MoreLinq/EquiZip.cs | 14 ++++++++++++++ MoreLinq/Extensions.g.cs | 42 ++++++++++++++++++++++++++++++++++++++++ MoreLinq/ZipLongest.cs | 14 ++++++++++++++ MoreLinq/ZipShortest.cs | 14 ++++++++++++++ 4 files changed, 84 insertions(+) diff --git a/MoreLinq/EquiZip.cs b/MoreLinq/EquiZip.cs index 1f2b351f6..61212f122 100644 --- a/MoreLinq/EquiZip.cs +++ b/MoreLinq/EquiZip.cs @@ -42,6 +42,10 @@ static partial class MoreEnumerable /// /// The input sequences are of different lengths. /// + /// + /// , , or is . + /// /// /// EquiZip( /// /// The input sequences are of different lengths. /// + /// + /// , , , or is . + /// /// /// EquiZip( /// /// The input sequences are of different lengths. /// + /// + /// , , , , or is . + /// /// /// /// The input sequences are of different lengths. /// + /// + /// , , or is . + /// /// /// EquiZip( /// /// The input sequences are of different lengths. /// + /// + /// , , , or is . + /// /// /// EquiZip( /// /// The input sequences are of different lengths. /// + /// + /// , , , , or is . + /// /// /// . /// + /// + /// , , or is . + /// /// /// ZipLongest( /// A sequence that contains elements of the three input sequences, /// combined by . /// + /// + /// , , , or is . + /// /// /// ZipLongest( /// A sequence that contains elements of the four input sequences, /// combined by . /// + /// + /// , , , , or is . + /// /// /// /// + /// + /// , , or is . + /// /// ZipShortest( /// /// A projection of tuples, where each tuple contains the N-th element /// from each of the argument sequences. + /// + /// , , , or is . + /// /// /// ZipShortest( /// /// A projection of tuples, where each tuple contains the N-th element /// from each of the argument sequences. + /// + /// , , , , or is . + /// /// /// . /// + /// + /// , , or is . + /// /// /// ZipLongest( /// A sequence that contains elements of the three input sequences, /// combined by . /// + /// + /// , , , or is . + /// /// /// ZipLongest( /// A sequence that contains elements of the four input sequences, /// combined by . /// + /// + /// , , , , or is . + /// /// /// /// + /// + /// , , or is . + /// /// ZipShortest( /// /// A projection of tuples, where each tuple contains the N-th element /// from each of the argument sequences. + /// + /// , , , or is . + /// /// /// ZipShortest( /// /// A projection of tuples, where each tuple contains the N-th element /// from each of the argument sequences. + /// + /// , , , , or is . + /// /// /// Date: Wed, 30 Nov 2022 16:53:43 -0600 Subject: [PATCH 008/157] Add identity method to reduce JIT-ing This is a squashed merge of PR ##880. Co-authored-by: Atif Aziz --- MoreLinq/Batch.cs | 2 +- MoreLinq/GroupAdjacent.cs | 6 +++--- MoreLinq/IdFn.cs | 24 ++++++++++++++++++++++++ MoreLinq/OrderedMerge.cs | 4 ++-- MoreLinq/Rank.cs | 4 ++-- MoreLinq/Split.cs | 6 +++--- 6 files changed, 35 insertions(+), 11 deletions(-) create mode 100644 MoreLinq/IdFn.cs diff --git a/MoreLinq/Batch.cs b/MoreLinq/Batch.cs index 34babc628..5bb2553e7 100644 --- a/MoreLinq/Batch.cs +++ b/MoreLinq/Batch.cs @@ -50,7 +50,7 @@ static partial class MoreEnumerable public static IEnumerable> Batch(this IEnumerable source, int size) { - return Batch(source, size, x => x); + return Batch(source, size, IdFn); } /// diff --git a/MoreLinq/GroupAdjacent.cs b/MoreLinq/GroupAdjacent.cs index cc57e5167..08bd069a6 100644 --- a/MoreLinq/GroupAdjacent.cs +++ b/MoreLinq/GroupAdjacent.cs @@ -87,7 +87,7 @@ public static IEnumerable> GroupAdjacent if (source == null) throw new ArgumentNullException(nameof(source)); if (keySelector == null) throw new ArgumentNullException(nameof(keySelector)); - return GroupAdjacent(source, keySelector, e => e, comparer); + return GroupAdjacent(source, keySelector, IdFn, comparer); } /// @@ -208,7 +208,7 @@ public static IEnumerable GroupAdjacent( // This should be removed once the target framework is bumped to something that supports covariance TResult ResultSelectorWrapper(TKey key, IList group) => resultSelector(key, group); - return GroupAdjacentImpl(source, keySelector, i => i, ResultSelectorWrapper, + return GroupAdjacentImpl(source, keySelector, IdFn, ResultSelectorWrapper, EqualityComparer.Default); } @@ -253,7 +253,7 @@ public static IEnumerable GroupAdjacent( // This should be removed once the target framework is bumped to something that supports covariance TResult ResultSelectorWrapper(TKey key, IList group) => resultSelector(key, group); - return GroupAdjacentImpl(source, keySelector, i => i, ResultSelectorWrapper, + return GroupAdjacentImpl(source, keySelector, IdFn, ResultSelectorWrapper, comparer ?? EqualityComparer.Default); } diff --git a/MoreLinq/IdFn.cs b/MoreLinq/IdFn.cs new file mode 100644 index 000000000..74a32f491 --- /dev/null +++ b/MoreLinq/IdFn.cs @@ -0,0 +1,24 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2022 Turning Code, LLC. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq +{ + static partial class MoreEnumerable + { + static T IdFn(T x) => x; + } +} diff --git a/MoreLinq/OrderedMerge.cs b/MoreLinq/OrderedMerge.cs index a42e08057..0e30e1517 100644 --- a/MoreLinq/OrderedMerge.cs +++ b/MoreLinq/OrderedMerge.cs @@ -70,7 +70,7 @@ public static IEnumerable OrderedMerge( IEnumerable second, IComparer? comparer) { - return OrderedMerge(first, second, e => e, f => f, s => s, (a, _) => a, comparer); + return OrderedMerge(first, second, IdFn, IdFn, IdFn, (a, _) => a, comparer); } /// @@ -98,7 +98,7 @@ public static IEnumerable OrderedMerge( IEnumerable second, Func keySelector) { - return OrderedMerge(first, second, keySelector, a => a, b => b, (a, _) => a, null); + return OrderedMerge(first, second, keySelector, IdFn, IdFn, (a, _) => a, null); } /// diff --git a/MoreLinq/Rank.cs b/MoreLinq/Rank.cs index 5dff3d13c..d2c81a382 100644 --- a/MoreLinq/Rank.cs +++ b/MoreLinq/Rank.cs @@ -32,7 +32,7 @@ public static partial class MoreEnumerable public static IEnumerable Rank(this IEnumerable source) { - return source.RankBy(x => x); + return source.RankBy(IdFn); } /// @@ -45,7 +45,7 @@ public static IEnumerable Rank(this IEnumerable source) public static IEnumerable Rank(this IEnumerable source, IComparer comparer) { - return source.RankBy(x => x, comparer); + return source.RankBy(IdFn, comparer); } /// diff --git a/MoreLinq/Split.cs b/MoreLinq/Split.cs index 3ff9f2c97..1e101be66 100644 --- a/MoreLinq/Split.cs +++ b/MoreLinq/Split.cs @@ -50,7 +50,7 @@ public static IEnumerable> Split(this IEnumerable< public static IEnumerable> Split(this IEnumerable source, TSource separator, int count) { - return Split(source, separator, count, s => s); + return Split(source, separator, count, IdFn); } /// @@ -129,7 +129,7 @@ public static IEnumerable> Split(this IEnumerable< public static IEnumerable> Split(this IEnumerable source, TSource separator, IEqualityComparer? comparer, int count) { - return Split(source, separator, comparer, count, s => s); + return Split(source, separator, comparer, count, IdFn); } /// @@ -216,7 +216,7 @@ public static IEnumerable> Split(this IEnumerable< public static IEnumerable> Split(this IEnumerable source, Func separatorFunc, int count) { - return Split(source, separatorFunc, count, s => s); + return Split(source, separatorFunc, count, IdFn); } /// From eeddf4dad049c0717cb6df544fc4e0413e968bbf Mon Sep 17 00:00:00 2001 From: Leonid Tsarev Date: Sat, 10 Dec 2022 17:48:51 +0300 Subject: [PATCH 009/157] Use "Random.Shared" on .NET 6+ (#907) Co-authored-by: Atif Aziz --- MoreLinq/GlobalRandom.cs | 71 ++++++++++++++++++++++++++++++++++++++++ MoreLinq/Random.cs | 60 +++++++++------------------------ MoreLinq/RandomSubset.cs | 2 +- MoreLinq/Shuffle.cs | 2 +- 4 files changed, 89 insertions(+), 46 deletions(-) create mode 100644 MoreLinq/GlobalRandom.cs diff --git a/MoreLinq/GlobalRandom.cs b/MoreLinq/GlobalRandom.cs new file mode 100644 index 000000000..7aa165c62 --- /dev/null +++ b/MoreLinq/GlobalRandom.cs @@ -0,0 +1,71 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2010 Leopold Bushkin. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq +{ + using System; +#if !NET6_0_OR_GREATER + using System.Threading; +#endif + + public static partial class MoreEnumerable + { + /// + /// is not thread-safe so the following + /// implementation uses thread-local + /// instances to create the illusion of a global + /// implementation. For some background, + /// see Getting + /// random numbers in a thread-safe way. + /// On .NET 6+, delegates to Random.Shared. + /// + + sealed class GlobalRandom : Random + { +#if NET6_0_OR_GREATER + public static Random Instance => Shared; +#else + public static Random Instance { get; } = new GlobalRandom(); + + static int _seed = Environment.TickCount; + [ThreadStatic] static Random? _threadRandom; + static Random ThreadRandom => _threadRandom ??= new Random(Interlocked.Increment(ref _seed)); + + GlobalRandom() { } + + public override int Next() => ThreadRandom.Next(); + public override int Next(int minValue, int maxValue) => ThreadRandom.Next(minValue, maxValue); + public override int Next(int maxValue) => ThreadRandom.Next(maxValue); + public override double NextDouble() => ThreadRandom.NextDouble(); + public override void NextBytes(byte[] buffer) => ThreadRandom.NextBytes(buffer); + + protected override double Sample() + { + // All the NextXXX calls are hijacked above to use the Random + // instance allocated for the thread so no call from the base + // class should ever end up here. If Random introduces new + // virtual members in the future that call into Sample and + // which end up getting used in the implementation of a + // randomizing operator from the outer class then they will + // need to be overriden. + + throw new NotImplementedException(); + } +#endif + } + } +} diff --git a/MoreLinq/Random.cs b/MoreLinq/Random.cs index 33566a3db..6d9b82700 100644 --- a/MoreLinq/Random.cs +++ b/MoreLinq/Random.cs @@ -19,7 +19,6 @@ namespace MoreLinq { using System; using System.Collections.Generic; - using System.Threading; public static partial class MoreEnumerable { @@ -29,6 +28,7 @@ public static partial class MoreEnumerable /// /// An infinite sequence of random integers /// + /// /// The implementation internally uses a shared, thread-local instance of /// to generate a random number on each /// iteration. The actual instance used @@ -41,7 +41,9 @@ public static partial class MoreEnumerable /// in the generation of the sequence of random numbers. Because the /// instance is shared, if multiple sequences /// are generated on the same thread, the order of enumeration affects the - /// resulting sequences. + /// resulting sequences. + /// + /// On .NET 6 or later, System.Random.Shared is used. /// public static IEnumerable Random() @@ -71,6 +73,7 @@ public static IEnumerable Random(Random rand) /// exclusive upper bound for the random values returned /// An infinite sequence of random integers /// + /// /// The implementation internally uses a shared, thread-local instance of /// to generate a random number on each /// iteration. The actual instance used @@ -83,7 +86,9 @@ public static IEnumerable Random(Random rand) /// in the generation of the sequence of random numbers. Because the /// instance is shared, if multiple sequences /// are generated on the same thread, the order of enumeration affects the - /// resulting sequences. + /// resulting sequences. + /// + /// On .NET 6 or later, System.Random.Shared is used. /// public static IEnumerable Random(int maxValue) @@ -118,6 +123,7 @@ public static IEnumerable Random(Random rand, int maxValue) /// Exclusive upper bound of the values returned /// An infinite sequence of random integers /// + /// /// The implementation internally uses a shared, thread-local instance of /// to generate a random number on each /// iteration. The actual instance used @@ -130,7 +136,9 @@ public static IEnumerable Random(Random rand, int maxValue) /// in the generation of the sequence of random numbers. Because the /// instance is shared, if multiple sequences /// are generated on the same thread, the order of enumeration affects the - /// resulting sequences. + /// resulting sequences. + /// + /// On .NET 6 or later, System.Random.Shared is used. /// public static IEnumerable Random(int minValue, int maxValue) @@ -166,6 +174,7 @@ public static IEnumerable Random(Random rand, int minValue, int maxValue) /// /// An infinite sequence of random doubles /// + /// /// The implementation internally uses a shared, thread-local instance of /// to generate a random number on each /// iteration. The actual instance used @@ -178,7 +187,9 @@ public static IEnumerable Random(Random rand, int minValue, int maxValue) /// in the generation of the sequence of random numbers. Because the /// instance is shared, if multiple sequences /// are generated on the same thread, the order of enumeration affects the - /// resulting sequences. + /// resulting sequences. + /// + /// On .NET 6 or later, System.Random.Shared is used. /// public static IEnumerable RandomDouble() @@ -215,44 +226,5 @@ static IEnumerable RandomImpl(Random rand, Func nextValue) while (true) yield return nextValue(rand); } - - /// - /// is not thread-safe so the following - /// implementation uses thread-local - /// instances to create the illusion of a global - /// implementation. For some background, - /// see Getting - /// random numbers in a thread-safe way - /// - - sealed class GlobalRandom : Random - { - public static readonly Random Instance = new GlobalRandom(); - - static int _seed = Environment.TickCount; - [ThreadStatic] static Random? _threadRandom; - static Random ThreadRandom => _threadRandom ??= new Random(Interlocked.Increment(ref _seed)); - - GlobalRandom() { } - - public override int Next() => ThreadRandom.Next(); - public override int Next(int minValue, int maxValue) => ThreadRandom.Next(minValue, maxValue); - public override int Next(int maxValue) => ThreadRandom.Next(maxValue); - public override double NextDouble() => ThreadRandom.NextDouble(); - public override void NextBytes(byte[] buffer) => ThreadRandom.NextBytes(buffer); - - protected override double Sample() - { - // All the NextXXX calls are hijacked above to use the Random - // instance allocated for the thread so no call from the base - // class should ever end up here. If Random introduces new - // virtual members in the future that call into Sample and - // which end up getting used in the implementation of a - // randomizing operator from the outer class then they will - // need to be overriden. - - throw new NotImplementedException(); - } - } } } diff --git a/MoreLinq/RandomSubset.cs b/MoreLinq/RandomSubset.cs index b3c192719..6aafdc5a1 100644 --- a/MoreLinq/RandomSubset.cs +++ b/MoreLinq/RandomSubset.cs @@ -37,7 +37,7 @@ public static partial class MoreEnumerable public static IEnumerable RandomSubset(this IEnumerable source, int subsetSize) { - return RandomSubset(source, subsetSize, new Random()); + return RandomSubset(source, subsetSize, GlobalRandom.Instance); } /// diff --git a/MoreLinq/Shuffle.cs b/MoreLinq/Shuffle.cs index 3b2f3df57..c7cac7d6e 100644 --- a/MoreLinq/Shuffle.cs +++ b/MoreLinq/Shuffle.cs @@ -42,7 +42,7 @@ public static partial class MoreEnumerable public static IEnumerable Shuffle(this IEnumerable source) { - return Shuffle(source, new Random()); + return Shuffle(source, GlobalRandom.Instance); } /// From 625ee56aa80254626ecd81a1bcf012674fc9b52e Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Sat, 17 Dec 2022 08:01:58 -0600 Subject: [PATCH 010/157] Fix "ZipLongest" signatures with more honest nullable annotations This is a squashed merge of PR #900 that adds to #803. --- MoreLinq.Test/ZipLongestTest.cs | 16 +++++++++------- MoreLinq/Extensions.g.cs | 6 +++--- MoreLinq/ZipLongest.cs | 6 +++--- 3 files changed, 15 insertions(+), 13 deletions(-) diff --git a/MoreLinq.Test/ZipLongestTest.cs b/MoreLinq.Test/ZipLongestTest.cs index f61470013..5b4e74789 100644 --- a/MoreLinq.Test/ZipLongestTest.cs +++ b/MoreLinq.Test/ZipLongestTest.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#nullable enable + namespace MoreLinq.Test { using System; @@ -31,13 +33,13 @@ public class ZipLongestTest public static readonly IEnumerable TestData = from e in new[] { - new { A = Seq( ), B = Seq("foo", "bar", "baz"), Result = Seq((0, "foo"), (0, "bar"), (0, "baz")) }, - new { A = Seq(1 ), B = Seq("foo", "bar", "baz"), Result = Seq((1, "foo"), (0, "bar"), (0, "baz")) }, - new { A = Seq(1, 2 ), B = Seq("foo", "bar", "baz"), Result = Seq((1, "foo"), (2, "bar"), (0, "baz")) }, - new { A = Seq(1, 2, 3), B = Seq( ), Result = Seq((1, null ), (2, null ), (3, (string) null)) }, - new { A = Seq(1, 2, 3), B = Seq("foo" ), Result = Seq((1, "foo"), (2, null ), (3, null )) }, - new { A = Seq(1, 2, 3), B = Seq("foo", "bar" ), Result = Seq((1, "foo"), (2, "bar"), (3, null )) }, - new { A = Seq(1, 2, 3), B = Seq("foo", "bar", "baz"), Result = Seq((1, "foo"), (2, "bar"), (3, "baz")) }, + new { A = Seq( ), B = Seq("foo", "bar", "baz"), Result = Seq<(int, string?)>((0, "foo"), (0, "bar"), (0, "baz")) }, + new { A = Seq(1 ), B = Seq("foo", "bar", "baz"), Result = Seq<(int, string?)>((1, "foo"), (0, "bar"), (0, "baz")) }, + new { A = Seq(1, 2 ), B = Seq("foo", "bar", "baz"), Result = Seq<(int, string?)>((1, "foo"), (2, "bar"), (0, "baz")) }, + new { A = Seq(1, 2, 3), B = Seq( ), Result = Seq<(int, string?)>((1, null ), (2, null ), (3, null )) }, + new { A = Seq(1, 2, 3), B = Seq("foo" ), Result = Seq<(int, string?)>((1, "foo"), (2, null ), (3, null )) }, + new { A = Seq(1, 2, 3), B = Seq("foo", "bar" ), Result = Seq<(int, string?)>((1, "foo"), (2, "bar"), (3, null )) }, + new { A = Seq(1, 2, 3), B = Seq("foo", "bar", "baz"), Result = Seq<(int, string?)>((1, "foo"), (2, "bar"), (3, "baz")) }, } select new TestCaseData(e.A, e.B) .Returns(e.Result); diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index 14d73e462..9e5b16a71 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -6837,7 +6837,7 @@ public static partial class ZipLongestExtension public static IEnumerable ZipLongest( this IEnumerable first, IEnumerable second, - Func resultSelector) + Func resultSelector) => MoreEnumerable.ZipLongest(first, second, resultSelector); /// @@ -6883,7 +6883,7 @@ public static IEnumerable ZipLongest( this IEnumerable first, IEnumerable second, IEnumerable third, - Func resultSelector) + Func resultSelector) => MoreEnumerable.ZipLongest(first, second, third, resultSelector); /// @@ -6933,7 +6933,7 @@ public static IEnumerable ZipLongest( IEnumerable second, IEnumerable third, IEnumerable fourth, - Func resultSelector) + Func resultSelector) => MoreEnumerable.ZipLongest(first, second, third, fourth, resultSelector); } diff --git a/MoreLinq/ZipLongest.cs b/MoreLinq/ZipLongest.cs index 5f93188d7..38e5fdefc 100644 --- a/MoreLinq/ZipLongest.cs +++ b/MoreLinq/ZipLongest.cs @@ -60,7 +60,7 @@ static partial class MoreEnumerable public static IEnumerable ZipLongest( this IEnumerable first, IEnumerable second, - Func resultSelector) + Func resultSelector) { if (first == null) throw new ArgumentNullException(nameof(first)); if (second == null) throw new ArgumentNullException(nameof(second)); @@ -112,7 +112,7 @@ public static IEnumerable ZipLongest( this IEnumerable first, IEnumerable second, IEnumerable third, - Func resultSelector) + Func resultSelector) { if (first == null) throw new ArgumentNullException(nameof(first)); if (second == null) throw new ArgumentNullException(nameof(second)); @@ -169,7 +169,7 @@ public static IEnumerable ZipLongest( IEnumerable second, IEnumerable third, IEnumerable fourth, - Func resultSelector) + Func resultSelector) { if (first == null) throw new ArgumentNullException(nameof(first)); if (second == null) throw new ArgumentNullException(nameof(second)); From ad137bf3873c4564777c998f335005536ae665ea Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 17 Dec 2022 15:41:29 +0100 Subject: [PATCH 011/157] Enable nullable context for remaining "*Zip*" tests This is a squashed merge of PR #908 that adds to #803. Co-authored-by: Stuart Turner --- MoreLinq.Test/EquiZipTest.cs | 2 ++ MoreLinq.Test/ZipShortestTest.cs | 2 ++ 2 files changed, 4 insertions(+) diff --git a/MoreLinq.Test/EquiZipTest.cs b/MoreLinq.Test/EquiZipTest.cs index f118f21eb..c90c2b4e6 100644 --- a/MoreLinq.Test/EquiZipTest.cs +++ b/MoreLinq.Test/EquiZipTest.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#nullable enable + namespace MoreLinq.Test { using System; diff --git a/MoreLinq.Test/ZipShortestTest.cs b/MoreLinq.Test/ZipShortestTest.cs index 3d2d8f80e..ae7de9f14 100644 --- a/MoreLinq.Test/ZipShortestTest.cs +++ b/MoreLinq.Test/ZipShortestTest.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#nullable enable + namespace MoreLinq.Test { using System; From e46acc204a84a0cf57d6848931d8030ccf97b439 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 17 Dec 2022 17:02:47 +0100 Subject: [PATCH 012/157] Add NUnit.Analyzers, addressing errors/warnings Warning addressed: - NUnit2015: https://github.com/nunit/nunit.analyzers/blob/3.5.0/documentation/NUnit2015.md - NUnit2005: https://github.com/nunit/nunit.analyzers/blob/3.5.0/documentation/NUnit2005.md - NUnit2031: https://github.com/nunit/nunit.analyzers/blob/3.5.0/documentation/NUnit2031.md This is a squashed merge of PR #910 that closes #909. --- MoreLinq.Test/AssertCountTest.cs | 4 ++-- MoreLinq.Test/AssertTest.cs | 2 +- MoreLinq.Test/CartesianTest.cs | 12 +++++----- MoreLinq.Test/CompareCountTest.cs | 24 ++++++++++---------- MoreLinq.Test/ConsumeTest.cs | 2 +- MoreLinq.Test/FallbackIfEmptyTest.cs | 16 ++++++------- MoreLinq.Test/FullGroupJoinTest.cs | 14 ++++++------ MoreLinq.Test/GroupAdjacentTest.cs | 2 +- MoreLinq.Test/LagTest.cs | 10 ++++---- MoreLinq.Test/LeadTest.cs | 10 ++++---- MoreLinq.Test/MaxByTest.cs | 12 +++++----- MoreLinq.Test/MinByTest.cs | 12 +++++----- MoreLinq.Test/MoreLinq.Test.csproj | 4 ++++ MoreLinq.Test/PermutationsTest.cs | 8 +++---- MoreLinq.Test/RandomSubsetTest.cs | 10 ++++---- MoreLinq.Test/RandomTest.cs | 12 +++++----- MoreLinq.Test/RankTest.cs | 12 +++++----- MoreLinq.Test/ScanTest.cs | 2 +- MoreLinq.Test/SegmentTest.cs | 8 +++---- MoreLinq.Test/SequenceTest.cs | 2 +- MoreLinq.Test/SliceTest.cs | 2 +- MoreLinq.Test/SubsetTest.cs | 4 ++-- MoreLinq.Test/ToDataTableTest.cs | 34 ++++++++++++++-------------- MoreLinq.Test/TransposeTest.cs | 2 +- MoreLinq.Test/WindowTest.cs | 6 ++--- 25 files changed, 115 insertions(+), 111 deletions(-) diff --git a/MoreLinq.Test/AssertCountTest.cs b/MoreLinq.Test/AssertCountTest.cs index fd1c21167..c38ac9661 100644 --- a/MoreLinq.Test/AssertCountTest.cs +++ b/MoreLinq.Test/AssertCountTest.cs @@ -112,7 +112,7 @@ public void AssertCountWithCollectionIsLazy() public void AssertCountWithMatchingCollectionCount() { var xs = new[] { 123, 456, 789 }; - Assert.AreSame(xs, xs.AssertCount(3)); + Assert.That(xs, Is.SameAs(xs.AssertCount(3))); } [TestCase(3, 2, "Sequence contains too many elements when exactly 2 were expected.")] @@ -122,7 +122,7 @@ public void AssertCountWithMismatchingCollectionCount(int sourceCount, int count var xs = new int[sourceCount]; using var enumerator = xs.AssertCount(count).GetEnumerator(); var e = Assert.Throws(() => enumerator.MoveNext()); - Assert.AreEqual(e.Message, message); + Assert.That(e.Message, Is.EqualTo(message)); } [Test] diff --git a/MoreLinq.Test/AssertTest.cs b/MoreLinq.Test/AssertTest.cs index 2d8cdf6a7..a15f0d94e 100644 --- a/MoreLinq.Test/AssertTest.cs +++ b/MoreLinq.Test/AssertTest.cs @@ -57,7 +57,7 @@ public void AssertSequenceWithInvalidElementsAndCustomError() var e = Assert.Throws(() => new[] { 2, 4, 6, 7, 8, 9 }.Assert(n => n % 2 == 0, n => new ValueException(n)).Consume()); - Assert.AreEqual(7, e.Value); + Assert.That(e.Value, Is.EqualTo(7)); } class ValueException : Exception diff --git a/MoreLinq.Test/CartesianTest.cs b/MoreLinq.Test/CartesianTest.cs index 36dcaebcb..19bab4e85 100644 --- a/MoreLinq.Test/CartesianTest.cs +++ b/MoreLinq.Test/CartesianTest.cs @@ -88,7 +88,7 @@ public void TestCartesianProductCount() var result = sequenceA.Cartesian(sequenceB, (a, b) => a + b); - Assert.AreEqual(expectedCount, result.Count() ); + Assert.That(result.Count(), Is.EqualTo(expectedCount)); } /// @@ -111,7 +111,7 @@ public void TestCartesianProductCount_Multidimensional() var result = sequenceA.Cartesian(sequenceB, sequenceC, sequenceD, (a, b, c, d) => a + b + c + d); const int expectedCount = countA * countB * countC * countD; - Assert.AreEqual(expectedCount, result.Count()); + Assert.That(result.Count(), Is.EqualTo(expectedCount)); } /// @@ -139,7 +139,7 @@ public void TestCartesianProductCombinations() .ToArray(); // verify that the expected number of results is correct - Assert.AreEqual(sequenceA.Count() * sequenceB.Count(), result.Count()); + Assert.That(result.Count(), Is.EqualTo(sequenceA.Count() * sequenceB.Count())); // ensure that all "cells" were visited by the cartesian product foreach (var coord in result) @@ -160,9 +160,9 @@ public void TestEmptyCartesianEvaluation() var resultB = Enumerable.Empty().Cartesian(sequence, (a, b) => new { A = a, B = b }); var resultC = Enumerable.Empty().Cartesian(Enumerable.Empty(), (a, b) => new { A = a, B = b }); - Assert.AreEqual(0, resultA.Count()); - Assert.AreEqual(0, resultB.Count()); - Assert.AreEqual(0, resultC.Count()); + Assert.That(resultA.Count(), Is.Zero); + Assert.That(resultB.Count(), Is.Zero); + Assert.That(resultC.Count(), Is.Zero); } } } diff --git a/MoreLinq.Test/CompareCountTest.cs b/MoreLinq.Test/CompareCountTest.cs index 96e2151ab..bc93e08de 100644 --- a/MoreLinq.Test/CompareCountTest.cs +++ b/MoreLinq.Test/CompareCountTest.cs @@ -57,8 +57,8 @@ public void CompareCountWithCollectionAndSequence(int collectionCount, using var seq = Enumerable.Range(0, sequenceCount).AsTestingSequence(); - Assert.AreEqual(expectedCompareCount, collection.CompareCount(seq)); - Assert.AreEqual(expectedMoveNextCallCount, seq.MoveNextCallCount); + Assert.That(collection.CompareCount(seq), Is.EqualTo(expectedCompareCount)); + Assert.That(seq.MoveNextCallCount, Is.EqualTo(expectedMoveNextCallCount)); } [TestCase(0, 0, 0, 1)] @@ -74,8 +74,8 @@ public void CompareCountWithSequenceAndCollection(int sequenceCount, using var seq = Enumerable.Range(0, sequenceCount).AsTestingSequence(); - Assert.AreEqual(expectedCompareCount, seq.CompareCount(collection)); - Assert.AreEqual(expectedMoveNextCallCount, seq.MoveNextCallCount); + Assert.That(seq.CompareCount(collection), Is.EqualTo(expectedCompareCount)); + Assert.That(seq.MoveNextCallCount, Is.EqualTo(expectedMoveNextCallCount)); } [TestCase(0, 0, 0, 1)] @@ -90,9 +90,9 @@ public void CompareCountWithSequenceAndSequence(int sequenceCount1, using var seq1 = Enumerable.Range(0, sequenceCount1).AsTestingSequence(); using var seq2 = Enumerable.Range(0, sequenceCount2).AsTestingSequence(); - Assert.AreEqual(expectedCompareCount, seq1.CompareCount(seq2)); - Assert.AreEqual(expectedMoveNextCallCount, seq1.MoveNextCallCount); - Assert.AreEqual(expectedMoveNextCallCount, seq2.MoveNextCallCount); + Assert.That(seq1.CompareCount(seq2), Is.EqualTo(expectedCompareCount)); + Assert.That(seq1.MoveNextCallCount, Is.EqualTo(expectedMoveNextCallCount)); + Assert.That(seq2.MoveNextCallCount, Is.EqualTo(expectedMoveNextCallCount)); } [Test] @@ -101,7 +101,7 @@ public void CompareCountDisposesSequenceEnumerators() using var seq1 = TestingSequence.Of(); using var seq2 = TestingSequence.Of(); - Assert.AreEqual(0, seq1.CompareCount(seq2)); + Assert.That(seq1.CompareCount(seq2), Is.Zero); } [Test] @@ -111,7 +111,7 @@ public void CompareCountDisposesFirstEnumerator() using var seq = TestingSequence.Of(); - Assert.AreEqual(0, seq.CompareCount(collection)); + Assert.That(seq.CompareCount(collection), Is.Zero); } [Test] @@ -121,7 +121,7 @@ public void CompareCountDisposesSecondEnumerator() using var seq = TestingSequence.Of(); - Assert.AreEqual(0, collection.CompareCount(seq)); + Assert.That(collection.CompareCount(seq), Is.Zero); } [Test] @@ -135,8 +135,8 @@ public void CompareCountDoesNotIterateUnnecessaryElements() var seq2 = Enumerable.Range(1, 3); - Assert.AreEqual( 1, seq1.CompareCount(seq2)); - Assert.AreEqual(-1, seq2.CompareCount(seq1)); + Assert.That(seq1.CompareCount(seq2), Is.EqualTo( 1)); + Assert.That(seq2.CompareCount(seq1), Is.EqualTo(-1)); } enum SequenceKind diff --git a/MoreLinq.Test/ConsumeTest.cs b/MoreLinq.Test/ConsumeTest.cs index 83279cabd..5d802b344 100644 --- a/MoreLinq.Test/ConsumeTest.cs +++ b/MoreLinq.Test/ConsumeTest.cs @@ -28,7 +28,7 @@ public void ConsumeReallyConsumes() var counter = 0; var sequence = Enumerable.Range(0, 10).Pipe(_ => counter++); sequence.Consume(); - Assert.AreEqual(10, counter); + Assert.That(counter, Is.EqualTo(10)); } } } diff --git a/MoreLinq.Test/FallbackIfEmptyTest.cs b/MoreLinq.Test/FallbackIfEmptyTest.cs index cf6a2df83..65ccfc788 100644 --- a/MoreLinq.Test/FallbackIfEmptyTest.cs +++ b/MoreLinq.Test/FallbackIfEmptyTest.cs @@ -42,12 +42,12 @@ public void FallbackIfEmptyPreservesSourceCollectionIfPossible(SourceKind source { var source = new[] { 1 }.ToSourceKind(sourceKind); // ReSharper disable PossibleMultipleEnumeration - Assert.AreSame(source.FallbackIfEmpty(12), source); - Assert.AreSame(source.FallbackIfEmpty(12, 23), source); - Assert.AreSame(source.FallbackIfEmpty(12, 23, 34), source); - Assert.AreSame(source.FallbackIfEmpty(12, 23, 34, 45), source); - Assert.AreSame(source.FallbackIfEmpty(12, 23, 34, 45, 56), source); - Assert.AreSame(source.FallbackIfEmpty(12, 23, 34, 45, 56, 67), source); + Assert.That(source.FallbackIfEmpty(12), Is.SameAs(source)); + Assert.That(source.FallbackIfEmpty(12, 23), Is.SameAs(source)); + Assert.That(source.FallbackIfEmpty(12, 23, 34), Is.SameAs(source)); + Assert.That(source.FallbackIfEmpty(12, 23, 34, 45), Is.SameAs(source)); + Assert.That(source.FallbackIfEmpty(12, 23, 34, 45, 56), Is.SameAs(source)); + Assert.That(source.FallbackIfEmpty(12, 23, 34, 45, 56, 67), Is.SameAs(source)); // ReSharper restore PossibleMultipleEnumeration } @@ -57,8 +57,8 @@ public void FallbackIfEmptyPreservesFallbackCollectionIfPossible(SourceKind sour { var source = new int[0].ToSourceKind(sourceKind); var fallback = new[] { 1 }; - Assert.AreSame(source.FallbackIfEmpty(fallback), fallback); - Assert.AreSame(source.FallbackIfEmpty(fallback.AsEnumerable()), fallback); + Assert.That(source.FallbackIfEmpty(fallback), Is.SameAs(fallback)); + Assert.That(source.FallbackIfEmpty(fallback.AsEnumerable()), Is.SameAs(fallback)); } [Test] diff --git a/MoreLinq.Test/FullGroupJoinTest.cs b/MoreLinq.Test/FullGroupJoinTest.cs index 1b7838ee3..e4cc3dd81 100644 --- a/MoreLinq.Test/FullGroupJoinTest.cs +++ b/MoreLinq.Test/FullGroupJoinTest.cs @@ -48,7 +48,7 @@ public void FullGroupJoinsResults(OverloadCase overloadCase) var result = FullGroupJoin(overloadCase, listA, listB, x => x).ToDictionary(a => a.Key); - Assert.AreEqual(3, result.Keys.Count); + Assert.That(result.Keys.Count, Is.EqualTo(3)); Assert.IsEmpty(result[1].Second); result[1].First.AssertSequenceEqual(1); @@ -69,13 +69,13 @@ public void FullGroupJoinsEmptyLeft(OverloadCase overloadCase) var result = FullGroupJoin(overloadCase, listA, listB, x => x).ToDictionary(a => a.Key); - Assert.AreEqual(2, result.Keys.Count); + Assert.That(result.Keys.Count, Is.EqualTo(2)); Assert.IsEmpty(result[2].First); - Assert.AreEqual(2, result[2].Second.Single()); + Assert.That(result[2].Second.Single(), Is.EqualTo(2)); Assert.IsEmpty(result[3].First); - Assert.AreEqual(3, result[3].Second.Single()); + Assert.That(result[3].Second.Single(), Is.EqualTo(3)); } [TestCase(CustomResult)] @@ -87,12 +87,12 @@ public void FullGroupJoinsEmptyRight(OverloadCase overloadCase) var result = FullGroupJoin(overloadCase, listA, listB, x => x).ToDictionary(a => a.Key); - Assert.AreEqual(2, result.Keys.Count); + Assert.That(result.Keys.Count, Is.EqualTo(2)); - Assert.AreEqual(2, result[2].First.Single()); + Assert.That(result[2].First.Single(), Is.EqualTo(2)); Assert.IsEmpty(result[2].Second); - Assert.AreEqual(3, result[3].First.Single()); + Assert.That(result[3].First.Single(), Is.EqualTo(3)); Assert.IsEmpty(result[3].Second); } diff --git a/MoreLinq.Test/GroupAdjacentTest.cs b/MoreLinq.Test/GroupAdjacentTest.cs index 8c23e5552..dbc1e8762 100644 --- a/MoreLinq.Test/GroupAdjacentTest.cs +++ b/MoreLinq.Test/GroupAdjacentTest.cs @@ -235,7 +235,7 @@ static void AssertResult(SequenceReader reader, TElement ele { var result = reader.Read(); Assert.That(result, Is.Not.Null); - Assert.AreEqual(element, result); + Assert.That(result, Is.EqualTo(element)); } } } diff --git a/MoreLinq.Test/LagTest.cs b/MoreLinq.Test/LagTest.cs index e41a91c83..192d9028c 100644 --- a/MoreLinq.Test/LagTest.cs +++ b/MoreLinq.Test/LagTest.cs @@ -69,7 +69,7 @@ public void TestLagExplicitDefaultValue() var sequence = Enumerable.Range(1, count); var result = sequence.Lag(lagBy, lagDefault, (_, lagVal) => lagVal); - Assert.AreEqual(count, result.Count()); + Assert.That(result.Count(), Is.EqualTo(count)); Assert.That(result.Take(lagBy), Is.EqualTo(Enumerable.Repeat(lagDefault, lagBy))); } @@ -84,7 +84,7 @@ public void TestLagImplicitDefaultValue() var sequence = Enumerable.Range(1, count); var result = sequence.Lag(lagBy, (_, lagVal) => lagVal); - Assert.AreEqual(count, result.Count()); + Assert.That(result.Count(), Is.EqualTo(count)); Assert.That(result.Take(lagBy), Is.EqualTo(Enumerable.Repeat(default(int), lagBy))); } @@ -99,7 +99,7 @@ public void TestLagOffsetGreaterThanSequenceLength() var sequence = Enumerable.Range(1, count); var result = sequence.Lag(count + 1, (a, _) => a); - Assert.AreEqual(count, result.Count()); + Assert.That(result.Count(), Is.EqualTo(count)); Assert.That(result, Is.EqualTo(sequence)); } @@ -114,7 +114,7 @@ public void TestLagPassesCorrectLagValueOffsetBy1() var sequence = Enumerable.Range(1, count); var result = sequence.Lag(1, (a, b) => new { A = a, B = b }); - Assert.AreEqual(count, result.Count()); + Assert.That(result.Count(), Is.EqualTo(count)); Assert.IsTrue(result.All(x => x.B == (x.A - 1))); } @@ -129,7 +129,7 @@ public void TestLagPassesCorrectLagValuesOffsetBy2() var sequence = Enumerable.Range(1, count); var result = sequence.Lag(2, (a, b) => new { A = a, B = b }); - Assert.AreEqual(count, result.Count()); + Assert.That(result.Count(), Is.EqualTo(count)); Assert.IsTrue(result.Skip(2).All(x => x.B == (x.A - 2))); Assert.IsTrue(result.Take(2).All(x => (x.A - x.B) == x.A)); } diff --git a/MoreLinq.Test/LeadTest.cs b/MoreLinq.Test/LeadTest.cs index 2298be7c9..4574cd333 100644 --- a/MoreLinq.Test/LeadTest.cs +++ b/MoreLinq.Test/LeadTest.cs @@ -69,7 +69,7 @@ public void TestLeadExplicitDefaultValue() var sequence = Enumerable.Range(1, count); var result = sequence.Lead(leadBy, leadDefault, (_, leadVal) => leadVal); - Assert.AreEqual(count, result.Count()); + Assert.That(result.Count(), Is.EqualTo(count)); Assert.That(result.Skip(count - leadBy), Is.EqualTo(Enumerable.Repeat(leadDefault, leadBy))); } @@ -84,7 +84,7 @@ public void TestLeadImplicitDefaultValue() var sequence = Enumerable.Range(1, count); var result = sequence.Lead(leadBy, (_, leadVal) => leadVal); - Assert.AreEqual(count, result.Count()); + Assert.That(result.Count(), Is.EqualTo(count)); Assert.That(result.Skip(count - leadBy), Is.EqualTo(Enumerable.Repeat(default(int), leadBy))); } @@ -100,7 +100,7 @@ public void TestLeadOffsetGreaterThanSequenceLength() var sequence = Enumerable.Range(1, count); var result = sequence.Lead(count + 1, leadDefault, (val, leadVal) => new { A = val, B = leadVal }); - Assert.AreEqual(count, result.Count()); + Assert.That(result.Count(), Is.EqualTo(count)); Assert.That(result, Is.EqualTo(sequence.Select(x => new { A = x, B = leadDefault }))); } @@ -115,7 +115,7 @@ public void TestLeadPassesCorrectValueOffsetBy1() var sequence = Enumerable.Range(1, count); var result = sequence.Lead(1, count + 1, (val, leadVal) => new { A = val, B = leadVal }); - Assert.AreEqual(count, result.Count()); + Assert.That(result.Count(), Is.EqualTo(count)); Assert.IsTrue(result.All(x => x.B == (x.A + 1))); } @@ -131,7 +131,7 @@ public void TestLeadPassesCorrectValueOffsetBy2() var sequence = Enumerable.Range(1, count); var result = sequence.Lead(2, leadDefault, (val, leadVal) => new { A = val, B = leadVal }); - Assert.AreEqual(count, result.Count()); + Assert.That(result.Count(), Is.EqualTo(count)); Assert.IsTrue(result.Take(count - 2).All(x => x.B == (x.A + 2))); Assert.IsTrue(result.Skip(count - 2).All(x => x.B == leadDefault && x.A is count or count - 1)); } diff --git a/MoreLinq.Test/MaxByTest.cs b/MoreLinq.Test/MaxByTest.cs index 6480e932e..7cab0440c 100644 --- a/MoreLinq.Test/MaxByTest.cs +++ b/MoreLinq.Test/MaxByTest.cs @@ -34,15 +34,15 @@ public void MaxByIsLazy() [Test] public void MaxByReturnsMaxima() { - Assert.AreEqual(new[] { "hello", "world" }, - SampleData.Strings.MaxBy(x => x.Length)); + Assert.That(SampleData.Strings.MaxBy(x => x.Length), + Is.EqualTo(new[] { "hello", "world" })); } [Test] public void MaxByNullComparer() { - Assert.AreEqual(SampleData.Strings.MaxBy(x => x.Length), - SampleData.Strings.MaxBy(x => x.Length, null)); + Assert.That(SampleData.Strings.MaxBy(x => x.Length, null), + Is.EqualTo(SampleData.Strings.MaxBy(x => x.Length))); } [Test] @@ -54,13 +54,13 @@ public void MaxByEmptySequence() [Test] public void MaxByWithNaturalComparer() { - Assert.AreEqual(new[] { "az" }, SampleData.Strings.MaxBy(x => x[1])); + Assert.That(SampleData.Strings.MaxBy(x => x[1]), Is.EqualTo(new[] { "az" })); } [Test] public void MaxByWithComparer() { - Assert.AreEqual(new[] { "aa" }, SampleData.Strings.MaxBy(x => x[1], Comparable.DescendingOrderComparer)); + Assert.That(SampleData.Strings.MaxBy(x => x[1], Comparable.DescendingOrderComparer), Is.EqualTo(new[] { "aa" })); } public class First diff --git a/MoreLinq.Test/MinByTest.cs b/MoreLinq.Test/MinByTest.cs index 79d2da26e..8482d29b3 100644 --- a/MoreLinq.Test/MinByTest.cs +++ b/MoreLinq.Test/MinByTest.cs @@ -34,15 +34,15 @@ public void MinByIsLazy() [Test] public void MinByReturnsMinima() { - Assert.AreEqual(new[] { "ax", "aa", "ab", "ay", "az" }, - SampleData.Strings.MinBy(x => x.Length)); + Assert.That(SampleData.Strings.MinBy(x => x.Length), + Is.EqualTo(new[] { "ax", "aa", "ab", "ay", "az" })); } [Test] public void MinByNullComparer() { - Assert.AreEqual(SampleData.Strings.MinBy(x => x.Length), - SampleData.Strings.MinBy(x => x.Length, null)); + Assert.That(SampleData.Strings.MinBy(x => x.Length, null), + Is.EqualTo(SampleData.Strings.MinBy(x => x.Length))); } [Test] @@ -54,13 +54,13 @@ public void MinByEmptySequence() [Test] public void MinByWithNaturalComparer() { - Assert.AreEqual(new[] { "aa" }, SampleData.Strings.MinBy(x => x[1])); + Assert.That(SampleData.Strings.MinBy(x => x[1]), Is.EqualTo(new[] { "aa" })); } [Test] public void MinByWithComparer() { - Assert.AreEqual(new[] { "az" }, SampleData.Strings.MinBy(x => x[1], Comparable.DescendingOrderComparer)); + Assert.That(SampleData.Strings.MinBy(x => x[1], Comparable.DescendingOrderComparer), Is.EqualTo(new[] { "az" })); } public class First diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index 273866c9b..535a85744 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -34,6 +34,10 @@ all + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + diff --git a/MoreLinq.Test/PermutationsTest.cs b/MoreLinq.Test/PermutationsTest.cs index fe2897556..768de6738 100644 --- a/MoreLinq.Test/PermutationsTest.cs +++ b/MoreLinq.Test/PermutationsTest.cs @@ -89,7 +89,7 @@ public void TestCardinalityThreePermutation() }; // should contain six permutations (as defined above) - Assert.AreEqual(expectedPermutations.Length, permutations.Count()); + Assert.That(permutations.Count(), Is.EqualTo(expectedPermutations.Length)); Assert.IsTrue(permutations.All(p => expectedPermutations.Contains(p, EqualityComparer.Create>((x, y) => x.SequenceEqual(y))))); } @@ -132,7 +132,7 @@ public void TestCardinalityFourPermutation() }; // should contain six permutations (as defined above) - Assert.AreEqual(expectedPermutations.Length, permutations.Count()); + Assert.That(permutations.Count(), Is.EqualTo(expectedPermutations.Length)); Assert.IsTrue(permutations.All(p => expectedPermutations.Contains(p, EqualityComparer.Create>((x, y) => x.SequenceEqual(y))))); } @@ -159,7 +159,7 @@ public void TestHigherCardinalityPermutations() { var permutedSet = set.Permutations(); var permutationCount = permutedSet.Count(); - Assert.AreEqual(Combinatorics.Factorial(set.Count()), permutationCount); + Assert.That(permutationCount, Is.EqualTo(Combinatorics.Factorial(set.Count()))); } } @@ -192,7 +192,7 @@ public void TestPermutationsAreIndependent() for (var j = 1; j < listPermutations.Count; j++) { if (j == i) continue; - Assert.AreNotSame(listPermutations[i], listPermutations[j]); + Assert.That(listPermutations[i], Is.Not.SameAs(listPermutations[j])); } } } diff --git a/MoreLinq.Test/RandomSubsetTest.cs b/MoreLinq.Test/RandomSubsetTest.cs index 50988c862..7f0e5edf5 100644 --- a/MoreLinq.Test/RandomSubsetTest.cs +++ b/MoreLinq.Test/RandomSubsetTest.cs @@ -66,7 +66,7 @@ public void TestRandomSubsetOfEmptySequence() var sequence = Enumerable.Empty(); var result = sequence.RandomSubset(0); // we can only get subsets <= sequence.Count() - Assert.AreEqual(0, result.Count()); + Assert.That(result.Count(), Is.Zero); } /// @@ -81,8 +81,8 @@ public void TestRandomSubsetSameLengthAsSequence() var resultB = sequence.RandomSubset(count, new Random(12345)); // ensure random subset is always a complete reordering of original sequence - Assert.AreEqual(count, resultA.Distinct().Count()); - Assert.AreEqual(count, resultB.Distinct().Count()); + Assert.That(resultA.Distinct().Count(), Is.EqualTo(count)); + Assert.That(resultB.Distinct().Count(), Is.EqualTo(count)); } /// @@ -98,8 +98,8 @@ public void TestRandomSubsetShorterThanSequence() var resultB = sequence.RandomSubset(subsetSize, new Random(12345)); // ensure random subset is always a distinct subset of original sequence - Assert.AreEqual(subsetSize, resultA.Distinct().Count()); - Assert.AreEqual(subsetSize, resultB.Distinct().Count()); + Assert.That(resultA.Distinct().Count(), Is.EqualTo(subsetSize)); + Assert.That(resultB.Distinct().Count(), Is.EqualTo(subsetSize)); } /// diff --git a/MoreLinq.Test/RandomTest.cs b/MoreLinq.Test/RandomTest.cs index 54b295127..6cf9f4ab9 100644 --- a/MoreLinq.Test/RandomTest.cs +++ b/MoreLinq.Test/RandomTest.cs @@ -68,8 +68,8 @@ public void TestRandomDouble() var resultB = MoreEnumerable.RandomDouble(new Random()).Take(RandomTrials); // NOTE: Unclear what should actually be verified here... some additional thought needed. - Assert.AreEqual(RandomTrials, resultA.Count()); - Assert.AreEqual(RandomTrials, resultB.Count()); + Assert.That(resultA.Count(), Is.EqualTo(RandomTrials)); + Assert.That(resultB.Count(), Is.EqualTo(RandomTrials)); Assert.IsTrue(resultA.All(x => x is >= 0.0 and < 1.0)); Assert.IsTrue(resultB.All(x => x is >= 0.0 and < 1.0)); } @@ -84,8 +84,8 @@ public void TestRandomMaxConstraint() var resultA = MoreEnumerable.Random(max).Take(RandomTrials); var resultB = MoreEnumerable.Random(new Random(), max).Take(RandomTrials); - Assert.AreEqual(RandomTrials, resultA.Count()); - Assert.AreEqual(RandomTrials, resultB.Count()); + Assert.That(resultA.Count(), Is.EqualTo(RandomTrials)); + Assert.That(resultB.Count(), Is.EqualTo(RandomTrials)); Assert.IsTrue(resultA.All(x => x < max)); Assert.IsTrue(resultB.All(x => x < max)); } @@ -101,8 +101,8 @@ public void TestRandomMinMaxConstraint() var resultA = MoreEnumerable.Random(min, max).Take(RandomTrials); var resultB = MoreEnumerable.Random(new Random(), min, max).Take(RandomTrials); - Assert.AreEqual(RandomTrials, resultA.Count()); - Assert.AreEqual(RandomTrials, resultB.Count()); + Assert.That(resultA.Count(), Is.EqualTo(RandomTrials)); + Assert.That(resultB.Count(), Is.EqualTo(RandomTrials)); Assert.IsTrue(resultA.All(x => x is >= min and < max)); Assert.IsTrue(resultB.All(x => x is >= min and < max)); } diff --git a/MoreLinq.Test/RankTest.cs b/MoreLinq.Test/RankTest.cs index de3852782..1187e408e 100644 --- a/MoreLinq.Test/RankTest.cs +++ b/MoreLinq.Test/RankTest.cs @@ -76,7 +76,7 @@ public void TestRankDescendingSequence() var result = sequence.AsTestingSequence().Rank().ToArray(); var expectedResult = Enumerable.Range(1, count); - Assert.AreEqual(count, result.Length); + Assert.That(result.Length, Is.EqualTo(count)); Assert.That(result, Is.EqualTo(expectedResult)); } @@ -92,7 +92,7 @@ public void TestRankByAscendingSeries() var result = sequence.AsTestingSequence().Rank().ToArray(); var expectedResult = Enumerable.Range(1, count).Reverse(); - Assert.AreEqual(count, result.Length); + Assert.That(result.Length, Is.EqualTo(count)); Assert.That(result, Is.EqualTo(expectedResult)); } @@ -106,7 +106,7 @@ public void TestRankEquivalentItems() var sequence = Enumerable.Repeat(1234, count); var result = sequence.AsTestingSequence().Rank().ToArray(); - Assert.AreEqual(count, result.Length); + Assert.That(result.Length, Is.EqualTo(count)); Assert.That(result, Is.EqualTo(Enumerable.Repeat(1, count))); } @@ -122,7 +122,7 @@ public void TestRankGroupedItems() .Concat(Enumerable.Range(0, count)); var result = sequence.AsTestingSequence().Rank(); - Assert.AreEqual(count, result.Distinct().Count()); + Assert.That(result.Distinct().Count(), Is.EqualTo(count)); Assert.That(result, Is.EqualTo(sequence.Reverse().Select(x => x + 1))); } @@ -136,7 +136,7 @@ public void TestRankOfHighestItemIsOne() var sequence = Enumerable.Range(1, count); var result = sequence.AsTestingSequence().Rank(); - Assert.AreEqual(1, result.OrderBy(x => x).First()); + Assert.That(result.OrderBy(x => x).First(), Is.EqualTo(1)); } /// @@ -158,7 +158,7 @@ public void TestRankByKeySelector() }; var result = sequence.AsTestingSequence().RankBy(x => x.Age).ToArray(); - Assert.AreEqual(sequence.Length, result.Length); + Assert.That(result.Length, Is.EqualTo(sequence.Length)); Assert.That(result, Is.EqualTo(sequence.Select(x => x.ExpectedRank))); } diff --git a/MoreLinq.Test/ScanTest.cs b/MoreLinq.Test/ScanTest.cs index ac6abaa32..e94c47dee 100644 --- a/MoreLinq.Test/ScanTest.cs +++ b/MoreLinq.Test/ScanTest.cs @@ -55,7 +55,7 @@ public void ScanDoesNotIterateExtra() [Test] public void SeededScanEmpty() { - Assert.AreEqual(-1, new int[0].Scan(-1, SampleData.Plus).Single()); + Assert.That(new int[0].Scan(-1, SampleData.Plus).Single(), Is.EqualTo(-1)); } [Test] diff --git a/MoreLinq.Test/SegmentTest.cs b/MoreLinq.Test/SegmentTest.cs index e15023a17..e072ccbd0 100644 --- a/MoreLinq.Test/SegmentTest.cs +++ b/MoreLinq.Test/SegmentTest.cs @@ -77,7 +77,7 @@ public void TestSegmentIsIdempotent() for (var i = 0; i < 2; i++) { Assert.IsTrue(segment.Any()); - Assert.AreEqual(value, segment.Single()); + Assert.That(segment.Single(), Is.EqualTo(value)); } } } @@ -127,10 +127,10 @@ public void VerifyCanSegmentByIndex() var sequence = Enumerable.Repeat(1, count); var result = sequence.Segment((_, i) => i % segmentSize == 0); - Assert.AreEqual(count / segmentSize, result.Count()); + Assert.That(result.Count(), Is.EqualTo(count / segmentSize)); foreach (var segment in result) { - Assert.AreEqual(segmentSize, segment.Count()); + Assert.That(segment.Count(), Is.EqualTo(segmentSize)); } } @@ -145,7 +145,7 @@ public void VerifyCanSegmentByPrevious() .SelectMany(x => Enumerable.Repeat(x, repCount)); var result = sequence.Segment((curr, prev, _) => curr != prev); - Assert.AreEqual(sequence.Distinct().Count(), result.Count()); + Assert.That(result.Count(), Is.EqualTo(sequence.Distinct().Count())); Assert.IsTrue(result.All(s => s.Count() == repCount)); } diff --git a/MoreLinq.Test/SequenceTest.cs b/MoreLinq.Test/SequenceTest.cs index d2e288be7..01f49ad16 100644 --- a/MoreLinq.Test/SequenceTest.cs +++ b/MoreLinq.Test/SequenceTest.cs @@ -124,7 +124,7 @@ public void SequenceEdgeCases(int start, int stop, int step, int count) { var result = MoreEnumerable.Sequence(start, stop, step); - Assert.AreEqual(result.Count(), count); + Assert.That(result.Count(), Is.EqualTo(count)); } [TestCase( 5, 10)] diff --git a/MoreLinq.Test/SliceTest.cs b/MoreLinq.Test/SliceTest.cs index 18e80eeea..4cc5efd86 100644 --- a/MoreLinq.Test/SliceTest.cs +++ b/MoreLinq.Test/SliceTest.cs @@ -142,7 +142,7 @@ public void TestSliceOptimization(SourceKind sourceKind) var result = sequence.Slice(sliceStart, sliceCount); - Assert.AreEqual(sliceCount, result.Count()); + Assert.That(result.Count(), Is.EqualTo(sliceCount)); CollectionAssert.AreEqual(Enumerable.Range(5, sliceCount), result); } } diff --git a/MoreLinq.Test/SubsetTest.cs b/MoreLinq.Test/SubsetTest.cs index 439631eaa..201a1ff36 100644 --- a/MoreLinq.Test/SubsetTest.cs +++ b/MoreLinq.Test/SubsetTest.cs @@ -107,7 +107,7 @@ public void TestAllSubsetsExpectedCount() var expectedCount = Math.Pow(2, count); - Assert.AreEqual(expectedCount, result.Count()); + Assert.That(result.Count(), Is.EqualTo(expectedCount)); } /// @@ -147,7 +147,7 @@ public void TestKSubsetExpectedCount() // number of subsets of a given size is defined by the binomial coefficient: c! / ((c-s)!*s!) var expectedSubsetCount = Combinatorics.Binomial(count, subsetSize); - Assert.AreEqual(expectedSubsetCount, result.Count()); + Assert.That(result.Count(), Is.EqualTo(expectedSubsetCount)); } /// diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs index b2d43b168..71118967a 100644 --- a/MoreLinq.Test/ToDataTableTest.cs +++ b/MoreLinq.Test/ToDataTableTest.cs @@ -130,27 +130,27 @@ public void ToDataTableSchemaInDeclarationOrder() // Assert properties first, then fields, then in declaration order - Assert.AreEqual("AString", dt.Columns[0].Caption); - Assert.AreEqual(typeof(string), dt.Columns[0].DataType); + Assert.That(dt.Columns[0].Caption, Is.EqualTo("AString")); + Assert.That(dt.Columns[0].DataType, Is.EqualTo(typeof(string))); - Assert.AreEqual("ANullableDecimal", dt.Columns[1].Caption); - Assert.AreEqual(typeof(decimal), dt.Columns[1].DataType); + Assert.That(dt.Columns[1].Caption, Is.EqualTo("ANullableDecimal")); + Assert.That(dt.Columns[1].DataType, Is.EqualTo(typeof(decimal))); - Assert.AreEqual("KeyField", dt.Columns[2].Caption); - Assert.AreEqual(typeof(int), dt.Columns[2].DataType); + Assert.That(dt.Columns[2].Caption, Is.EqualTo("KeyField")); + Assert.That(dt.Columns[2].DataType, Is.EqualTo(typeof(int))); - Assert.AreEqual("ANullableGuidField", dt.Columns[3].Caption); - Assert.AreEqual(typeof(Guid), dt.Columns[3].DataType); + Assert.That(dt.Columns[3].Caption, Is.EqualTo("ANullableGuidField")); + Assert.That(dt.Columns[3].DataType, Is.EqualTo(typeof(Guid))); Assert.IsTrue(dt.Columns[3].AllowDBNull); - Assert.AreEqual(4, dt.Columns.Count); + Assert.That(dt.Columns.Count, Is.EqualTo(4)); } [Test] public void ToDataTableContainsAllElements() { var dt = _testObjects.ToDataTable(); - Assert.AreEqual(_testObjects.Count, dt.Rows.Count); + Assert.That(dt.Rows.Count, Is.EqualTo(_testObjects.Count)); } [Test] @@ -158,10 +158,10 @@ public void ToDataTableWithExpression() { var dt = _testObjects.ToDataTable(t => t.AString); - Assert.AreEqual("AString", dt.Columns[0].Caption); - Assert.AreEqual(typeof(string), dt.Columns[0].DataType); + Assert.That(dt.Columns[0].Caption, Is.EqualTo("AString")); + Assert.That(dt.Columns[0].DataType, Is.EqualTo(typeof(string))); - Assert.AreEqual(1, dt.Columns.Count); + Assert.That(dt.Columns.Count, Is.EqualTo(1)); } [Test] @@ -201,15 +201,15 @@ public void ToDataTableIgnoresStaticMembers() { var points = new[] { new Point(12, 34) }.ToDataTable(); - Assert.AreEqual(3, points.Columns.Count); + Assert.That(points.Columns.Count, Is.EqualTo(3)); DataColumn x, y, empty; Assert.NotNull(x = points.Columns["X"]); Assert.NotNull(y = points.Columns["Y"]); Assert.NotNull(empty = points.Columns["IsEmpty"]); var row = points.Rows.Cast().Single(); - Assert.AreEqual(12, row[x]); - Assert.AreEqual(34, row[y]); - Assert.AreEqual(false, row[empty]); + Assert.That(row[x], Is.EqualTo(12)); + Assert.That(row[y], Is.EqualTo(34)); + Assert.That(row[empty], Is.False); } } } diff --git a/MoreLinq.Test/TransposeTest.cs b/MoreLinq.Test/TransposeTest.cs index 097734165..5bdc2422a 100644 --- a/MoreLinq.Test/TransposeTest.cs +++ b/MoreLinq.Test/TransposeTest.cs @@ -215,7 +215,7 @@ static void AssertMatrix(IEnumerable> expectation, IEnumerable var resultList = result.ToList(); var expectationList = expectation.ToList(); - Assert.AreEqual(expectationList.Count, resultList.Count); + Assert.That(resultList.Count, Is.EqualTo(expectationList.Count)); expectationList.Zip(resultList, ValueTuple.Create) .ForEach(t => t.Item1.AssertSequenceEqual(t.Item2)); diff --git a/MoreLinq.Test/WindowTest.cs b/MoreLinq.Test/WindowTest.cs index b9ae4bf18..e711dba11 100644 --- a/MoreLinq.Test/WindowTest.cs +++ b/MoreLinq.Test/WindowTest.cs @@ -116,11 +116,11 @@ public void TestWindowOfSingleElement() var result = sequence.Window(1); // number of windows should be equal to the source sequence length - Assert.AreEqual(count, result.Count()); + Assert.That(result.Count(), Is.EqualTo(count)); // each window should contain single item consistent of element at that offset var index = -1; foreach (var window in result) - Assert.AreEqual(sequence.ElementAt(++index), window.Single()); + Assert.That(window.Single(), Is.EqualTo(sequence.ElementAt(++index))); } /// @@ -152,7 +152,7 @@ public void TestWindowSmallerThanSequence() var result = sequence.Window(windowSize); // ensure that the number of windows is correct - Assert.AreEqual(count - windowSize + 1, result.Count()); + Assert.That(result.Count(), Is.EqualTo(count - windowSize + 1)); // ensure each window contains the correct set of items var index = -1; foreach (var window in result) From 3d887eeaaadf851560548e0fa86d32fae1e581ad Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 18 Dec 2022 17:52:06 +0100 Subject: [PATCH 013/157] Remove unused imports --- MoreLinq.Test/FromTest.cs | 1 - MoreLinq.Test/PadTest.cs | 1 - MoreLinq.Test/ToDataTableTest.cs | 1 - 3 files changed, 3 deletions(-) diff --git a/MoreLinq.Test/FromTest.cs b/MoreLinq.Test/FromTest.cs index 8dbe01375..cee487dc0 100644 --- a/MoreLinq.Test/FromTest.cs +++ b/MoreLinq.Test/FromTest.cs @@ -18,7 +18,6 @@ namespace MoreLinq.Test { using System; - using System.Collections.Generic; using NUnit.Framework; class FromTest diff --git a/MoreLinq.Test/PadTest.cs b/MoreLinq.Test/PadTest.cs index a7d2ccc58..1c1c2533e 100644 --- a/MoreLinq.Test/PadTest.cs +++ b/MoreLinq.Test/PadTest.cs @@ -19,7 +19,6 @@ namespace MoreLinq.Test { - using System.Collections.Generic; using NUnit.Framework; [TestFixture] diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs index 71118967a..f095a93a3 100644 --- a/MoreLinq.Test/ToDataTableTest.cs +++ b/MoreLinq.Test/ToDataTableTest.cs @@ -22,7 +22,6 @@ namespace MoreLinq.Test using System.Collections.Generic; using System.Data; using System.Linq.Expressions; - using System.Text.RegularExpressions; using NUnit.Framework; [TestFixture] From e603f1c1fabdaea511a3a22c731acb48547b8dd0 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 18 Dec 2022 23:17:44 +0100 Subject: [PATCH 014/157] Update all tests to consistently use NUnit's constraint model This is a squashed merge of PR #912. --- MoreLinq.Test/AcquireTest.cs | 2 +- MoreLinq.Test/AggregateRightTest.cs | 5 +-- MoreLinq.Test/AssertCountTest.cs | 55 ++++++++++++++------------- MoreLinq.Test/AssertTest.cs | 19 +++++---- MoreLinq.Test/AssertThrowsArgument.cs | 48 ----------------------- MoreLinq.Test/AtLeastTest.cs | 24 ++++++------ MoreLinq.Test/AtMostTest.cs | 18 ++++----- MoreLinq.Test/BacksertTest.cs | 8 ++-- MoreLinq.Test/BatchTest.cs | 12 +++--- MoreLinq.Test/CartesianTest.cs | 2 +- MoreLinq.Test/CountBetweenTest.cs | 16 ++++---- MoreLinq.Test/EndsWithTest.cs | 14 +++---- MoreLinq.Test/EquiZipTest.cs | 23 +++++------ MoreLinq.Test/ExactlyTest.cs | 14 +++---- MoreLinq.Test/ExcludeTest.cs | 8 ++-- MoreLinq.Test/FlattenTest.cs | 8 ++-- MoreLinq.Test/FoldTest.cs | 12 +++--- MoreLinq.Test/FullGroupJoinTest.cs | 12 +++--- MoreLinq.Test/FullJoinTest.cs | 20 ++++++---- MoreLinq.Test/IndexByTest.cs | 4 +- MoreLinq.Test/InsertTest.cs | 9 ++--- MoreLinq.Test/InterleaveTest.cs | 7 ++-- MoreLinq.Test/LagTest.cs | 14 +++---- MoreLinq.Test/LeadTest.cs | 14 +++---- MoreLinq.Test/LeftJoinTest.cs | 20 ++++++---- MoreLinq.Test/MaxByTest.cs | 21 +++++----- MoreLinq.Test/MemoizeTest.cs | 34 ++++++++--------- MoreLinq.Test/MinByTest.cs | 17 ++++----- MoreLinq.Test/MoreLinq.Test.csproj | 2 +- MoreLinq.Test/MoveTest.cs | 12 +++--- MoreLinq.Test/PadStartTest.cs | 6 +-- MoreLinq.Test/PadTest.cs | 3 +- MoreLinq.Test/PermutationsTest.cs | 8 ++-- MoreLinq.Test/RandomSubsetTest.cs | 24 +++++------- MoreLinq.Test/RandomTest.cs | 24 ++++++------ MoreLinq.Test/RepeatTest.cs | 6 +-- MoreLinq.Test/RightJoinTest.cs | 20 ++++++---- MoreLinq.Test/ScanByTest.cs | 4 +- MoreLinq.Test/ScanTest.cs | 5 +-- MoreLinq.Test/SegmentTest.cs | 16 ++++---- MoreLinq.Test/SequenceTest.cs | 2 +- MoreLinq.Test/SliceTest.cs | 2 +- MoreLinq.Test/SortedMergeTest.cs | 5 ++- MoreLinq.Test/StartsWithTest.cs | 14 +++---- MoreLinq.Test/SubjectTest.cs | 4 +- MoreLinq.Test/SubsetTest.cs | 12 +++--- MoreLinq.Test/TakeEveryTest.cs | 8 ++-- MoreLinq.Test/TestingSequence.cs | 2 +- MoreLinq.Test/Throws.cs | 52 +++++++++++++++++++++++++ MoreLinq.Test/ToArrayByIndexTest.cs | 16 ++++---- MoreLinq.Test/ToDataTableTest.cs | 36 +++++++++--------- MoreLinq.Test/TransposeTest.cs | 12 +++--- MoreLinq.Test/WindowLeftTest.cs | 4 +- MoreLinq.Test/WindowRightTest.cs | 4 +- MoreLinq.Test/WindowTest.cs | 4 +- MoreLinq.Test/ZipLongestTest.cs | 4 +- MoreLinq.Test/ZipShortestTest.cs | 5 +-- 57 files changed, 392 insertions(+), 384 deletions(-) delete mode 100644 MoreLinq.Test/AssertThrowsArgument.cs create mode 100644 MoreLinq.Test/Throws.cs diff --git a/MoreLinq.Test/AcquireTest.cs b/MoreLinq.Test/AcquireTest.cs index 4e687078b..c29d09933 100644 --- a/MoreLinq.Test/AcquireTest.cs +++ b/MoreLinq.Test/AcquireTest.cs @@ -57,7 +57,7 @@ public void AcquireSome() () => throw new TestException(), () => c = new Disposable()); - Assert.Throws(() => allocators.Acquire()); + Assert.That(allocators.Acquire, Throws.TypeOf()); Assert.That(a, Is.Not.Null); Assert.That(a.Disposed, Is.True); diff --git a/MoreLinq.Test/AggregateRightTest.cs b/MoreLinq.Test/AggregateRightTest.cs index 4128577d8..434d16c93 100644 --- a/MoreLinq.Test/AggregateRightTest.cs +++ b/MoreLinq.Test/AggregateRightTest.cs @@ -17,7 +17,6 @@ namespace MoreLinq.Test { - using System; using NUnit.Framework; [TestFixture] @@ -28,8 +27,8 @@ public class AggregateRightTest [Test] public void AggregateRightWithEmptySequence() { - Assert.Throws( - () => new int[0].AggregateRight((a, b) => a + b)); + Assert.That(() => new int[0].AggregateRight((a, b) => a + b), + Throws.InvalidOperationException); } [Test] diff --git a/MoreLinq.Test/AssertCountTest.cs b/MoreLinq.Test/AssertCountTest.cs index c38ac9661..a9bf9ca53 100644 --- a/MoreLinq.Test/AssertCountTest.cs +++ b/MoreLinq.Test/AssertCountTest.cs @@ -27,10 +27,10 @@ public class AssertCountTest public void AssertCountNegativeCount() { var source = new object[0]; - AssertThrowsArgument.OutOfRangeException("count", () => - source.AssertCount(-1)); - AssertThrowsArgument.OutOfRangeException("count", () => - source.AssertCount(-1, BreakingFunc.Of())); + Assert.That(() => source.AssertCount(-1), + Throws.ArgumentOutOfRangeException("count")); + Assert.That(() => source.AssertCount(-1, BreakingFunc.Of()), + Throws.ArgumentOutOfRangeException("count")); } [Test] @@ -42,46 +42,47 @@ public void AssertCountSequenceWithMatchingLength() [Test] public void AssertCountShortSequence() { - Assert.Throws(() => - "foo,bar,baz".GenerateSplits(',').AssertCount(4).Consume()); + Assert.That(() => "foo,bar,baz".GenerateSplits(',').AssertCount(4).Consume(), + Throws.TypeOf()); } [Test] public void AssertCountLongSequence() { - Assert.Throws(() => - "foo,bar,baz".GenerateSplits(',').AssertCount(2).Consume()); + Assert.That(() => "foo,bar,baz".GenerateSplits(',').AssertCount(2).Consume(), + Throws.TypeOf()); } - [Test] - public void AssertCountDefaultExceptionMessageVariesWithCase() + [TestCase(4, "Sequence contains too few elements when exactly 4 were expected.")] + [TestCase(2, "Sequence contains too many elements when exactly 2 were expected.")] + public void AssertCountDefaultExceptionMessageVariesWithCase(int count, string expectedMessage) { var tokens = "foo,bar,baz".GenerateSplits(','); - var e1 = Assert.Throws(() => tokens.AssertCount(4).Consume()); - var e2 = Assert.Throws(() => tokens.AssertCount(2).Consume()); - Assert.That(e1.Message, Is.Not.EqualTo(e2.Message)); + + Assert.That(() => tokens.AssertCount(count).Consume(), + Throws.TypeOf().With.Message.EqualTo(expectedMessage)); } [Test] public void AssertCountLongSequenceWithErrorSelector() { - var e = - Assert.Throws(() => - "foo,bar,baz".GenerateSplits(',').AssertCount(2, (cmp, count) => new TestException(cmp, count)) - .Consume()); - Assert.That(e.Cmp, Is.GreaterThan(0)); - Assert.That(e.Count, Is.EqualTo(2)); + Assert.That(() => + "foo,bar,baz".GenerateSplits(',').AssertCount(2, (cmp, count) => new TestException(cmp, count)) + .Consume(), + Throws.TypeOf() + .With.Property(nameof(TestException.Cmp)).GreaterThan(0) + .And.Count.EqualTo(2)); } [Test] public void AssertCountShortSequenceWithErrorSelector() { - var e = - Assert.Throws(() => - "foo,bar,baz".GenerateSplits(',').AssertCount(4, (cmp, count) => new TestException(cmp, count)) - .Consume()); - Assert.That(e.Cmp, Is.LessThan(0)); - Assert.That(e.Count, Is.EqualTo(4)); + Assert.That(() => + "foo,bar,baz".GenerateSplits(',').AssertCount(4, (cmp, count) => new TestException(cmp, count)) + .Consume(), + Throws.TypeOf() + .With.Property(nameof(TestException.Cmp)).LessThan(0) + .And.Count.EqualTo(4)); } sealed class TestException : Exception @@ -121,8 +122,8 @@ public void AssertCountWithMismatchingCollectionCount(int sourceCount, int count { var xs = new int[sourceCount]; using var enumerator = xs.AssertCount(count).GetEnumerator(); - var e = Assert.Throws(() => enumerator.MoveNext()); - Assert.That(e.Message, Is.EqualTo(message)); + Assert.That(enumerator.MoveNext, + Throws.TypeOf().With.Message.EqualTo(message)); } [Test] diff --git a/MoreLinq.Test/AssertTest.cs b/MoreLinq.Test/AssertTest.cs index a15f0d94e..ff77f609f 100644 --- a/MoreLinq.Test/AssertTest.cs +++ b/MoreLinq.Test/AssertTest.cs @@ -40,24 +40,27 @@ public void AssertSequenceWithValidAllElements() [Test] public void AssertSequenceWithValidSomeInvalidElements() { - Assert.Throws(() => - new[] { 2, 4, 6, 7, 8, 9 }.Assert(n => n % 2 == 0).Consume()); + var source = new[] { 2, 4, 6, 7, 8, 9 }; + Assert.That(() => source.Assert(n => n % 2 == 0).Consume(), + Throws.InvalidOperationException); } [Test] public void AssertSequenceWithInvalidElementsAndCustomErrorReturningNull() { - Assert.Throws(() => - new[] { 2, 4, 6, 7, 8, 9 }.Assert(n => n % 2 == 0, _ => null).Consume()); + var source = new[] { 2, 4, 6, 7, 8, 9 }; + Assert.That(() => source.Assert(n => n % 2 == 0, _ => null).Consume(), + Throws.InvalidOperationException); } [Test] public void AssertSequenceWithInvalidElementsAndCustomError() { - var e = - Assert.Throws(() => - new[] { 2, 4, 6, 7, 8, 9 }.Assert(n => n % 2 == 0, n => new ValueException(n)).Consume()); - Assert.That(e.Value, Is.EqualTo(7)); + var source = new[] { 2, 4, 6, 7, 8, 9 }; + Assert.That(() => + source.Assert(n => n % 2 == 0, n => new ValueException(n)).Consume(), + Throws.TypeOf() + .With.Property(nameof(ValueException.Value)).EqualTo(7)); } class ValueException : Exception diff --git a/MoreLinq.Test/AssertThrowsArgument.cs b/MoreLinq.Test/AssertThrowsArgument.cs deleted file mode 100644 index ade934394..000000000 --- a/MoreLinq.Test/AssertThrowsArgument.cs +++ /dev/null @@ -1,48 +0,0 @@ -#region License and Terms -// MoreLINQ - Extensions to LINQ to Objects -// Copyright (c) 2017 George Vovos. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -#endregion - -namespace MoreLinq.Test -{ - using System; - using NUnit.Framework; - - sealed class AssertThrowsArgument - { - [Obsolete("This is redundant with the NullArgumentTest fixture.")] - public static void NullException(string expectedParamName, TestDelegate code) - { - Exception(expectedParamName, code); - } - - public static void Exception(string expectedParamName, TestDelegate code) - { - Exception(expectedParamName, code); - } - - public static void OutOfRangeException(string expectedParamName, TestDelegate code) - { - Exception(expectedParamName, code); - } - - static void Exception(string expectedParamName, TestDelegate code) where TActual : ArgumentException - { - var e = Assert.Throws(code); - - Assert.That(e.ParamName, Is.EqualTo(expectedParamName)); - } - } -} diff --git a/MoreLinq.Test/AtLeastTest.cs b/MoreLinq.Test/AtLeastTest.cs index 691b7ae99..f4ad24f88 100644 --- a/MoreLinq.Test/AtLeastTest.cs +++ b/MoreLinq.Test/AtLeastTest.cs @@ -25,71 +25,71 @@ public class AtLeastTest [Test] public void AtLeastWithNegativeCount() { - AssertThrowsArgument.OutOfRangeException("count", () => - new[] { 1 }.AtLeast(-1)); + Assert.That(() => new[] { 1 }.AtLeast(-1), + Throws.ArgumentOutOfRangeException("count")); } [Test] public void AtLeastWithEmptySequenceHasAtLeastZeroElements() { foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.IsTrue(xs.AtLeast(0)); + Assert.That(xs.AtLeast(0), Is.True); } [Test] public void AtLeastWithEmptySequenceHasAtLeastOneElement() { foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.IsFalse(xs.AtLeast(1)); + Assert.That(xs.AtLeast(1), Is.False); } [Test] public void AtLeastWithEmptySequenceHasAtLeastManyElements() { foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.IsFalse(xs.AtLeast(2)); + Assert.That(xs.AtLeast(2), Is.False); } [Test] public void AtLeastWithSingleElementHasAtLeastZeroElements() { foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.IsTrue(xs.AtLeast(0)); + Assert.That(xs.AtLeast(0), Is.True); } [Test] public void AtLeastWithSingleElementHasAtLeastOneElement() { foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.IsTrue(xs.AtLeast(1)); + Assert.That(xs.AtLeast(1), Is.True); } [Test] public void AtLeastWithSingleElementHasAtLeastManyElements() { foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.IsFalse(xs.AtLeast(2)); + Assert.That(xs.AtLeast(2), Is.False); } [Test] public void AtLeastWithManyElementsHasAtLeastZeroElements() { foreach (var xs in new[] { 1, 2, 3 }.ArrangeCollectionTestCases()) - Assert.IsTrue(xs.AtLeast(0)); + Assert.That(xs.AtLeast(0), Is.True); } [Test] public void AtLeastWithManyElementsHasAtLeastOneElement() { foreach (var xs in new[] { 1, 2, 3 }.ArrangeCollectionTestCases()) - Assert.IsTrue(xs.AtLeast(1)); + Assert.That(xs.AtLeast(1), Is.True); } [Test] public void AtLeastWithManyElementsHasAtLeastManyElements() { foreach (var xs in new[] { 1, 2, 3 }.ArrangeCollectionTestCases()) - Assert.IsTrue(xs.AtLeast(2)); + Assert.That(xs.AtLeast(2), Is.True); } [Test] @@ -98,7 +98,7 @@ public void AtLeastDoesNotIterateUnnecessaryElements() var source = MoreEnumerable.From(() => 1, () => 2, () => throw new TestException()); - Assert.IsTrue(source.AtLeast(2)); + Assert.That(source.AtLeast(2), Is.True); } } } diff --git a/MoreLinq.Test/AtMostTest.cs b/MoreLinq.Test/AtMostTest.cs index f16b9e41c..14135b930 100644 --- a/MoreLinq.Test/AtMostTest.cs +++ b/MoreLinq.Test/AtMostTest.cs @@ -25,50 +25,50 @@ public class AtMostTest [Test] public void AtMostWithNegativeCount() { - AssertThrowsArgument.OutOfRangeException("count", - () => new[] { 1 }.AtMost(-1)); + Assert.That(() => new[] { 1 }.AtMost(-1), + Throws.ArgumentOutOfRangeException("count")); } [Test] public void AtMostWithEmptySequenceHasAtMostZeroElements() { foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.IsTrue(xs.AtMost(0)); + Assert.That(xs.AtMost(0), Is.True); } [Test] public void AtMostWithEmptySequenceHasAtMostOneElement() { foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.IsTrue(xs.AtMost(1)); + Assert.That(xs.AtMost(1), Is.True); } [Test] public void AtMostWithSingleElementHasAtMostZeroElements() { foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.IsFalse(xs.AtMost(0)); + Assert.That(xs.AtMost(0), Is.False); } [Test] public void AtMostWithSingleElementHasAtMostOneElement() { foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.IsTrue(xs.AtMost(1)); + Assert.That(xs.AtMost(1), Is.True); } [Test] public void AtMostWithSingleElementHasAtMostManyElements() { foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.IsTrue(xs.AtMost(2)); + Assert.That(xs.AtMost(2), Is.True); } [Test] public void AtMostWithManyElementsHasAtMostOneElements() { foreach (var xs in new[] { 1, 2, 3 }.ArrangeCollectionTestCases()) - Assert.IsFalse(xs.AtMost(1)); + Assert.That(xs.AtMost(1), Is.False); } [Test] @@ -78,7 +78,7 @@ public void AtMostDoesNotIterateUnnecessaryElements() () => 2, () => 3, () => throw new TestException()); - Assert.IsFalse(source.AtMost(2)); + Assert.That(source.AtMost(2), Is.False); } } } diff --git a/MoreLinq.Test/BacksertTest.cs b/MoreLinq.Test/BacksertTest.cs index 511a2f88f..a26e6ac8f 100644 --- a/MoreLinq.Test/BacksertTest.cs +++ b/MoreLinq.Test/BacksertTest.cs @@ -17,7 +17,6 @@ namespace MoreLinq.Test { - using System; using System.Collections.Generic; using NUnit.Framework; @@ -33,8 +32,8 @@ public void BacksertIsLazy() [Test] public void BacksertWithNegativeIndex() { - AssertThrowsArgument.OutOfRangeException("index", () => - Enumerable.Range(1, 10).Backsert(new[] { 97, 98, 99 }, -1)); + Assert.That(() => Enumerable.Range(1, 10).Backsert(new[] { 97, 98, 99 }, -1), + Throws.ArgumentOutOfRangeException("index")); } [TestCase(new[] { 1, 2, 3 }, 4, new[] { 9 })] @@ -45,7 +44,8 @@ public void BacksertWithIndexGreaterThanSourceLength(int[] seq1, int index, int[ var result = test1.Backsert(test2, index); - Assert.Throws(() => result.ElementAt(0)); + Assert.That(() => result.ElementAt(0), + Throws.ArgumentOutOfRangeException()); } [TestCase(new[] { 1, 2, 3 }, 0, new[] { 8, 9 }, ExpectedResult = new[] { 1, 2, 3, 8, 9 })] diff --git a/MoreLinq.Test/BatchTest.cs b/MoreLinq.Test/BatchTest.cs index a459ee2dd..ef923b9dd 100644 --- a/MoreLinq.Test/BatchTest.cs +++ b/MoreLinq.Test/BatchTest.cs @@ -27,8 +27,8 @@ public class BatchTest [TestCase(-1)] public void BatchBadSize(int size) { - AssertThrowsArgument.OutOfRangeException("size", () => - new object[0].Batch(size)); + Assert.That(() => new object[0].Batch(size), + Throws.ArgumentOutOfRangeException("size")); } [Test] @@ -153,10 +153,10 @@ public class BatchPoolTest [TestCase(-1)] public void BatchBadSize(int size) { - AssertThrowsArgument.OutOfRangeException("size", () => - new object[0].Batch(size, ArrayPool.Shared, - BreakingFunc.Of, IEnumerable>(), - BreakingFunc.Of, object>())); + Assert.That(() => new object[0].Batch(size, ArrayPool.Shared, + BreakingFunc.Of, IEnumerable>(), + BreakingFunc.Of, object>()), + Throws.ArgumentOutOfRangeException("size")); } [Test] diff --git a/MoreLinq.Test/CartesianTest.cs b/MoreLinq.Test/CartesianTest.cs index 19bab4e85..4277eb7bf 100644 --- a/MoreLinq.Test/CartesianTest.cs +++ b/MoreLinq.Test/CartesianTest.cs @@ -144,7 +144,7 @@ public void TestCartesianProductCombinations() // ensure that all "cells" were visited by the cartesian product foreach (var coord in result) expectedSet[coord.A][coord.B] = true; - Assert.IsTrue(expectedSet.SelectMany(x => x).All(z => z)); + Assert.That(expectedSet.SelectMany(x => x).All(z => z), Is.True); } /// diff --git a/MoreLinq.Test/CountBetweenTest.cs b/MoreLinq.Test/CountBetweenTest.cs index 2fc5fe4cc..6e57ba32c 100644 --- a/MoreLinq.Test/CountBetweenTest.cs +++ b/MoreLinq.Test/CountBetweenTest.cs @@ -25,29 +25,29 @@ public class CountBetweenTest [Test] public void CountBetweenWithNegativeMin() { - AssertThrowsArgument.OutOfRangeException("min", () => - new[] { 1 }.CountBetween(-1, 0)); + Assert.That(() => new[] { 1 }.CountBetween(-1, 0), + Throws.ArgumentOutOfRangeException("min")); } [Test] public void CountBetweenWithNegativeMax() { - AssertThrowsArgument.OutOfRangeException("max", () => - new[] { 1 }.CountBetween(0, -1)); + Assert.That(() => new[] { 1 }.CountBetween(0, -1), + Throws.ArgumentOutOfRangeException("max")); } [Test] public void CountBetweenWithMaxLesserThanMin() { - AssertThrowsArgument.OutOfRangeException("max", () => - new[] { 1 }.CountBetween(1, 0)); + Assert.That(() => new[] { 1 }.CountBetween(1, 0), + Throws.ArgumentOutOfRangeException("max")); } [Test] public void CountBetweenWithMaxEqualsMin() { foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.IsTrue(xs.CountBetween(1, 1)); + Assert.That(xs.CountBetween(1, 1), Is.True); } [TestCase(1, 2, 4, false)] @@ -69,7 +69,7 @@ public void CountBetweenDoesNotIterateUnnecessaryElements() () => 3, () => 4, () => throw new TestException()); - Assert.False(source.CountBetween(2, 3)); + Assert.That(source.CountBetween(2, 3), Is.False); } } } diff --git a/MoreLinq.Test/EndsWithTest.cs b/MoreLinq.Test/EndsWithTest.cs index 7d4c1cb14..316dc7271 100644 --- a/MoreLinq.Test/EndsWithTest.cs +++ b/MoreLinq.Test/EndsWithTest.cs @@ -52,13 +52,13 @@ public bool EndsWithWithStrings(string first, string second) [Test] public void EndsWithReturnsTrueIfBothEmpty() { - Assert.True(new int[0].EndsWith(new int[0])); + Assert.That(new int[0].EndsWith(new int[0]), Is.True); } [Test] public void EndsWithReturnsFalseIfOnlyFirstIsEmpty() { - Assert.False(new int[0].EndsWith(new[] {1,2,3})); + Assert.That(new int[0].EndsWith(new[] {1,2,3}), Is.False); } [TestCase("", "", ExpectedResult = true)] @@ -85,10 +85,10 @@ public void EndsWithUsesSpecifiedEqualityComparerOrDefault() var first = new[] {1,2,3}; var second = new[] {4,5,6}; - Assert.False(first.EndsWith(second)); - Assert.False(first.EndsWith(second, null)); - Assert.False(first.EndsWith(second, EqualityComparer.Create(delegate { return false; }))); - Assert.True(first.EndsWith(second, EqualityComparer.Create(delegate { return true; }))); + Assert.That(first.EndsWith(second), Is.False); + Assert.That(first.EndsWith(second, null), Is.False); + Assert.That(first.EndsWith(second, EqualityComparer.Create(delegate { return false; })), Is.False); + Assert.That(first.EndsWith(second, EqualityComparer.Create(delegate { return true; })), Is.True); } [TestCase(SourceKind.BreakingCollection)] @@ -98,7 +98,7 @@ public void EndsWithUsesCollectionsCountToAvoidUnnecessaryIteration(SourceKind s var first = new[] { 1, 2 }.ToSourceKind(sourceKind); var second = new[] { 1, 2, 3 }.ToSourceKind(sourceKind); - Assert.False(first.EndsWith(second)); + Assert.That(first.EndsWith(second), Is.False); } } } diff --git a/MoreLinq.Test/EquiZipTest.cs b/MoreLinq.Test/EquiZipTest.cs index c90c2b4e6..c0d18b0af 100644 --- a/MoreLinq.Test/EquiZipTest.cs +++ b/MoreLinq.Test/EquiZipTest.cs @@ -19,7 +19,6 @@ namespace MoreLinq.Test { - using System; using NUnit.Framework; using Tuple = System.ValueTuple; @@ -33,8 +32,8 @@ public void BothSequencesDisposedWithUnequalLengthsAndLongerFirst() using var shorter = TestingSequence.Of(1, 2); // Yes, this will throw... but then we should still have disposed both sequences - Assert.Throws(() => - longer.EquiZip(shorter, (x, y) => x + y).Consume()); + Assert.That(() => longer.EquiZip(shorter, (x, y) => x + y).Consume(), + Throws.InvalidOperationException); } [Test] @@ -44,8 +43,8 @@ public void BothSequencesDisposedWithUnequalLengthsAndShorterFirst() using var shorter = TestingSequence.Of(1, 2); // Yes, this will throw... but then we should still have disposed both sequences - Assert.Throws(() => - shorter.EquiZip(longer, (x, y) => x + y).Consume()); + Assert.That(() => shorter.EquiZip(longer, (x, y) => x + y).Consume(), + Throws.InvalidOperationException); } [Test] @@ -61,8 +60,7 @@ public void ZipWithFirstSequenceShorterThanSecondFailStrategy() { var zipped = new[] { 1, 2 }.EquiZip(new[] { 4, 5, 6 }, Tuple.Create); Assert.That(zipped, Is.Not.Null); - Assert.Throws(() => - zipped.Consume()); + Assert.That(zipped.Consume, Throws.InvalidOperationException); } [Test] @@ -70,8 +68,7 @@ public void ZipWithFirstSequnceLongerThanSecondFailStrategy() { var zipped = new[] { 1, 2, 3 }.EquiZip(new[] { 4, 5 }, Tuple.Create); Assert.That(zipped, Is.Not.Null); - Assert.Throws(() => - zipped.Consume()); + Assert.That(zipped.Consume, Throws.InvalidOperationException); } [Test] @@ -91,8 +88,8 @@ public void MoveNextIsNotCalledUnnecessarily() () => throw new TestException()) .AsTestingSequence(); - Assert.Throws(() => - s1.EquiZip(s2, s3, (x, y, z) => x + y + z).Consume()); + Assert.That(() => s1.EquiZip(s2, s3, (x, y, z) => x + y + z).Consume(), + Throws.InvalidOperationException); } [Test] @@ -100,8 +97,8 @@ public void ZipDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); - Assert.Throws(() => - s1.EquiZip(new BreakingSequence(), Tuple.Create).Consume()); + Assert.That(() => s1.EquiZip(new BreakingSequence(), Tuple.Create).Consume(), + Throws.InvalidOperationException); } } } diff --git a/MoreLinq.Test/ExactlyTest.cs b/MoreLinq.Test/ExactlyTest.cs index 938847f14..0d765d139 100644 --- a/MoreLinq.Test/ExactlyTest.cs +++ b/MoreLinq.Test/ExactlyTest.cs @@ -25,36 +25,36 @@ public class ExactlyTest [Test] public void ExactlyWithNegativeCount() { - AssertThrowsArgument.OutOfRangeException("count", () => - new[] { 1 }.Exactly(-1)); + Assert.That(() => new[] { 1 }.Exactly(-1), + Throws.ArgumentOutOfRangeException("count")); } [Test] public void ExactlyWithEmptySequenceHasExactlyZeroElements() { foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.IsTrue(xs.Exactly(0)); + Assert.That(xs.Exactly(0), Is.True); } [Test] public void ExactlyWithEmptySequenceHasExactlyOneElement() { foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.IsFalse(xs.Exactly(1)); + Assert.That(xs.Exactly(1), Is.False); } [Test] public void ExactlyWithSingleElementHasExactlyOneElements() { foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.IsTrue(xs.Exactly(1)); + Assert.That(xs.Exactly(1), Is.True); } [Test] public void ExactlyWithManyElementHasExactlyOneElement() { foreach (var xs in new[] { 1, 2, 3 }.ArrangeCollectionTestCases()) - Assert.IsFalse(xs.Exactly(1)); + Assert.That(xs.Exactly(1), Is.False); } [Test] @@ -64,7 +64,7 @@ public void ExactlyDoesNotIterateUnnecessaryElements() () => 2, () => 3, () => throw new TestException()); - Assert.IsFalse(source.Exactly(2)); + Assert.That(source.Exactly(2), Is.False); } } } diff --git a/MoreLinq.Test/ExcludeTest.cs b/MoreLinq.Test/ExcludeTest.cs index 61cd5241f..07e54cb2a 100644 --- a/MoreLinq.Test/ExcludeTest.cs +++ b/MoreLinq.Test/ExcludeTest.cs @@ -40,8 +40,8 @@ public void TestExcludeIsLazy() [Test] public void TestExcludeNegativeStartIndexException() { - AssertThrowsArgument.OutOfRangeException("startIndex",() => - Enumerable.Range(1, 10).Exclude(-10, 10)); + Assert.That(() => Enumerable.Range(1, 10).Exclude(-10, 10), + Throws.ArgumentOutOfRangeException("startIndex")); } /// @@ -50,8 +50,8 @@ public void TestExcludeNegativeStartIndexException() [Test] public void TestExcludeNegativeCountException() { - AssertThrowsArgument.OutOfRangeException("count",() => - Enumerable.Range(1, 10).Exclude(0, -5)); + Assert.That(() => Enumerable.Range(1, 10).Exclude(0, -5), + Throws.ArgumentOutOfRangeException("count")); } /// diff --git a/MoreLinq.Test/FlattenTest.cs b/MoreLinq.Test/FlattenTest.cs index 84b9c0a93..2cbbdb940 100644 --- a/MoreLinq.Test/FlattenTest.cs +++ b/MoreLinq.Test/FlattenTest.cs @@ -257,8 +257,8 @@ public void FlattenInterruptedIterationDisposesInnerSequences() using var inner3 = TestingSequence.Of(6, inner2, 7); using var source = TestingSequence.Of(inner1, inner3); - Assert.Throws(() => - source.Flatten().Consume()); + Assert.That(() => source.Flatten().Consume(), + Throws.TypeOf()); } [Test] @@ -291,8 +291,8 @@ public void FlattenEvaluatesInnerSequencesLazily() Assert.That(result.Take(10), Is.EqualTo(expectations)); - Assert.Throws(() => - source.Flatten().ElementAt(11)); + Assert.That(() => source.Flatten().ElementAt(11), + Throws.TypeOf()); } // Flatten(this IEnumerable source, Func selector) diff --git a/MoreLinq.Test/FoldTest.cs b/MoreLinq.Test/FoldTest.cs index 0c1c7185a..25b2d8101 100644 --- a/MoreLinq.Test/FoldTest.cs +++ b/MoreLinq.Test/FoldTest.cs @@ -26,22 +26,22 @@ public class FoldTest [Test] public void FoldWithTooFewItems() { - Assert.Throws(() => - Enumerable.Range(1, 3).Fold(BreakingFunc.Of())); + Assert.That(() => Enumerable.Range(1, 3).Fold(BreakingFunc.Of()), + Throws.TypeOf()); } [Test] public void FoldWithEmptySequence() { - Assert.Throws(() => - Enumerable.Empty().Fold(BreakingFunc.Of())); + Assert.That(() => Enumerable.Empty().Fold(BreakingFunc.Of()), + Throws.TypeOf()); } [Test] public void FoldWithTooManyItems() { - Assert.Throws(() => - Enumerable.Range(1, 3).Fold(BreakingFunc.Of())); + Assert.That(() => Enumerable.Range(1, 3).Fold(BreakingFunc.Of()), + Throws.TypeOf()); } [Test] diff --git a/MoreLinq.Test/FullGroupJoinTest.cs b/MoreLinq.Test/FullGroupJoinTest.cs index e4cc3dd81..9a73c6ba9 100644 --- a/MoreLinq.Test/FullGroupJoinTest.cs +++ b/MoreLinq.Test/FullGroupJoinTest.cs @@ -50,10 +50,10 @@ public void FullGroupJoinsResults(OverloadCase overloadCase) Assert.That(result.Keys.Count, Is.EqualTo(3)); - Assert.IsEmpty(result[1].Second); + Assert.That(result[1].Second, Is.Empty); result[1].First.AssertSequenceEqual(1); - Assert.IsEmpty(result[3].First); + Assert.That(result[3].First, Is.Empty); result[3].Second.AssertSequenceEqual(3); result[2].First.AssertSequenceEqual(2); @@ -71,10 +71,10 @@ public void FullGroupJoinsEmptyLeft(OverloadCase overloadCase) Assert.That(result.Keys.Count, Is.EqualTo(2)); - Assert.IsEmpty(result[2].First); + Assert.That(result[2].First, Is.Empty); Assert.That(result[2].Second.Single(), Is.EqualTo(2)); - Assert.IsEmpty(result[3].First); + Assert.That(result[3].First, Is.Empty); Assert.That(result[3].Second.Single(), Is.EqualTo(3)); } @@ -90,10 +90,10 @@ public void FullGroupJoinsEmptyRight(OverloadCase overloadCase) Assert.That(result.Keys.Count, Is.EqualTo(2)); Assert.That(result[2].First.Single(), Is.EqualTo(2)); - Assert.IsEmpty(result[2].Second); + Assert.That(result[2].Second, Is.Empty); Assert.That(result[3].First.Single(), Is.EqualTo(3)); - Assert.IsEmpty(result[3].Second); + Assert.That(result[3].Second, Is.Empty); } [TestCase(CustomResult)] diff --git a/MoreLinq.Test/FullJoinTest.cs b/MoreLinq.Test/FullJoinTest.cs index 88d22b6f2..f648727de 100644 --- a/MoreLinq.Test/FullJoinTest.cs +++ b/MoreLinq.Test/FullJoinTest.cs @@ -32,11 +32,12 @@ public void FullJoinWithHomogeneousSequencesIsLazy() var xs = new BreakingSequence(); var ys = new BreakingSequence(); - Assert.DoesNotThrow(() => + Assert.That(() => xs.FullJoin(ys, e => e, BreakingFunc.Of(), BreakingFunc.Of(), - BreakingFunc.Of())); + BreakingFunc.Of()), + Throws.Nothing); } [Test] @@ -45,12 +46,13 @@ public void FullJoinWithHomogeneousSequencesWithComparerIsLazy() var xs = new BreakingSequence(); var ys = new BreakingSequence(); - Assert.DoesNotThrow(() => + Assert.That(() => xs.FullJoin(ys, e => e, BreakingFunc.Of(), BreakingFunc.Of(), BreakingFunc.Of(), - comparer: null)); + comparer: null), + Throws.Nothing); } [Test] @@ -59,11 +61,12 @@ public void FullJoinIsLazy() var xs = new BreakingSequence(); var ys = new BreakingSequence(); - Assert.DoesNotThrow(() => + Assert.That(() => xs.FullJoin(ys, x => x, y => y.GetHashCode(), BreakingFunc.Of(), BreakingFunc.Of(), - BreakingFunc.Of())); + BreakingFunc.Of()), + Throws.Nothing); } [Test] @@ -72,12 +75,13 @@ public void FullJoinWithComparerIsLazy() var xs = new BreakingSequence(); var ys = new BreakingSequence(); - Assert.DoesNotThrow(() => + Assert.That(() => xs.FullJoin(ys, x => x, y => y.GetHashCode(), BreakingFunc.Of(), BreakingFunc.Of(), BreakingFunc.Of(), - comparer: null)); + comparer: null), + Throws.Nothing); } [Test] diff --git a/MoreLinq.Test/IndexByTest.cs b/MoreLinq.Test/IndexByTest.cs index 2a02d7474..da62a738a 100644 --- a/MoreLinq.Test/IndexByTest.cs +++ b/MoreLinq.Test/IndexByTest.cs @@ -116,8 +116,8 @@ public void IndexBytDoesNotIterateUnnecessaryElements() KeyValuePair.Create(1, "bob" ), KeyValuePair.Create(0, "davi" )); - Assert.Throws(() => - result.ElementAt(5)); + Assert.That(() => result.ElementAt(5), + Throws.TypeOf()); } } } diff --git a/MoreLinq.Test/InsertTest.cs b/MoreLinq.Test/InsertTest.cs index b8d51f514..7f9af900f 100644 --- a/MoreLinq.Test/InsertTest.cs +++ b/MoreLinq.Test/InsertTest.cs @@ -25,8 +25,8 @@ public class InsertTest [Test] public void InsertWithNegativeIndex() { - AssertThrowsArgument.OutOfRangeException("index", () => - Enumerable.Range(1, 10).Insert(new[] { 97, 98, 99 }, -1)); + Assert.That(() => Enumerable.Range(1, 10).Insert(new[] { 97, 98, 99 }, -1), + Throws.ArgumentOutOfRangeException("index")); } [TestCase(7)] @@ -42,9 +42,8 @@ public void InsertWithIndexGreaterThanSourceLengthMaterialized(int count) var result = test1.Insert(test2, count + 1); - AssertThrowsArgument.OutOfRangeException("index", () => - result.ForEach((e, index) => - Assert.That(e, Is.EqualTo(seq1[index])))); + Assert.That(() => result.ForEach((e, index) => Assert.That(e, Is.EqualTo(seq1[index]))), + Throws.ArgumentOutOfRangeException("index")); } [TestCase(7)] diff --git a/MoreLinq.Test/InterleaveTest.cs b/MoreLinq.Test/InterleaveTest.cs index b201a776e..ad9b02c6a 100644 --- a/MoreLinq.Test/InterleaveTest.cs +++ b/MoreLinq.Test/InterleaveTest.cs @@ -17,7 +17,6 @@ namespace MoreLinq.Test { - using System; using NUnit.Framework; /// @@ -46,7 +45,8 @@ public void TestInterleaveDisposesOnErrorAtGetEnumerator() var sequenceB = new BreakingSequence(); // Expected and thrown by BreakingSequence - Assert.Throws(() => sequenceA.Interleave(sequenceB).Consume()); + Assert.That(() => sequenceA.Interleave(sequenceB).Consume(), + Throws.InvalidOperationException); } /// @@ -60,7 +60,8 @@ public void TestInterleaveDisposesOnErrorAtMoveNext() using var sequenceB = MoreEnumerable.From(() => throw new TestException()).AsTestingSequence(); // Expected and thrown by sequenceB - Assert.Throws(() => sequenceA.Interleave(sequenceB).Consume()); + Assert.That(() => sequenceA.Interleave(sequenceB).Consume(), + Throws.TypeOf()); } /// diff --git a/MoreLinq.Test/LagTest.cs b/MoreLinq.Test/LagTest.cs index 192d9028c..fbd0262ff 100644 --- a/MoreLinq.Test/LagTest.cs +++ b/MoreLinq.Test/LagTest.cs @@ -43,8 +43,8 @@ public void TestLagIsLazy() [Test] public void TestLagNegativeOffsetException() { - AssertThrowsArgument.OutOfRangeException("offset",() => - Enumerable.Repeat(1, 10).Lag(-10, (val, _) => val)); + Assert.That(() => Enumerable.Repeat(1, 10).Lag(-10, (val, _) => val), + Throws.ArgumentOutOfRangeException("offset")); } /// @@ -53,8 +53,8 @@ public void TestLagNegativeOffsetException() [Test] public void TestLagZeroOffset() { - AssertThrowsArgument.OutOfRangeException("offset", () => - Enumerable.Range(1, 10).Lag(0, (val, lagVal) => val + lagVal)); + Assert.That(() => Enumerable.Range(1, 10).Lag(0, (val, lagVal) => val + lagVal), + Throws.ArgumentOutOfRangeException("offset")); } /// @@ -115,7 +115,7 @@ public void TestLagPassesCorrectLagValueOffsetBy1() var result = sequence.Lag(1, (a, b) => new { A = a, B = b }); Assert.That(result.Count(), Is.EqualTo(count)); - Assert.IsTrue(result.All(x => x.B == (x.A - 1))); + Assert.That(result.All(x => x.B == (x.A - 1)), Is.True); } /// @@ -130,8 +130,8 @@ public void TestLagPassesCorrectLagValuesOffsetBy2() var result = sequence.Lag(2, (a, b) => new { A = a, B = b }); Assert.That(result.Count(), Is.EqualTo(count)); - Assert.IsTrue(result.Skip(2).All(x => x.B == (x.A - 2))); - Assert.IsTrue(result.Take(2).All(x => (x.A - x.B) == x.A)); + Assert.That(result.Skip(2).All(x => x.B == (x.A - 2)), Is.True); + Assert.That(result.Take(2).All(x => (x.A - x.B) == x.A), Is.True); } [Test] diff --git a/MoreLinq.Test/LeadTest.cs b/MoreLinq.Test/LeadTest.cs index 4574cd333..ccff7fb03 100644 --- a/MoreLinq.Test/LeadTest.cs +++ b/MoreLinq.Test/LeadTest.cs @@ -43,8 +43,8 @@ public void TestLeadIsLazy() [Test] public void TestLeadNegativeOffset() { - AssertThrowsArgument.OutOfRangeException("offset", () => - Enumerable.Range(1, 100).Lead(-5, (val, leadVal) => val + leadVal)); + Assert.That(() => Enumerable.Range(1, 100).Lead(-5, (val, leadVal) => val + leadVal), + Throws.ArgumentOutOfRangeException("offset")); } /// @@ -53,8 +53,8 @@ public void TestLeadNegativeOffset() [Test] public void TestLeadZeroOffset() { - AssertThrowsArgument.OutOfRangeException("offset", () => - Enumerable.Range(1, 100).Lead(0, (val, leadVal) => val + leadVal)); + Assert.That(() => Enumerable.Range(1, 100).Lead(0, (val, leadVal) => val + leadVal), + Throws.ArgumentOutOfRangeException("offset")); } /// @@ -116,7 +116,7 @@ public void TestLeadPassesCorrectValueOffsetBy1() var result = sequence.Lead(1, count + 1, (val, leadVal) => new { A = val, B = leadVal }); Assert.That(result.Count(), Is.EqualTo(count)); - Assert.IsTrue(result.All(x => x.B == (x.A + 1))); + Assert.That(result.All(x => x.B == (x.A + 1)), Is.True); } /// @@ -132,8 +132,8 @@ public void TestLeadPassesCorrectValueOffsetBy2() var result = sequence.Lead(2, leadDefault, (val, leadVal) => new { A = val, B = leadVal }); Assert.That(result.Count(), Is.EqualTo(count)); - Assert.IsTrue(result.Take(count - 2).All(x => x.B == (x.A + 2))); - Assert.IsTrue(result.Skip(count - 2).All(x => x.B == leadDefault && x.A is count or count - 1)); + Assert.That(result.Take(count - 2).All(x => x.B == (x.A + 2)), Is.True); + Assert.That(result.Skip(count - 2).All(x => x.B == leadDefault && x.A is count or count - 1), Is.True); } [Test] diff --git a/MoreLinq.Test/LeftJoinTest.cs b/MoreLinq.Test/LeftJoinTest.cs index 9bd5d7bdc..76214fb8d 100644 --- a/MoreLinq.Test/LeftJoinTest.cs +++ b/MoreLinq.Test/LeftJoinTest.cs @@ -32,10 +32,11 @@ public void LeftJoinWithHomogeneousSequencesIsLazy() var xs = new BreakingSequence(); var ys = new BreakingSequence(); - Assert.DoesNotThrow(() => + Assert.That(() => xs.LeftJoin(ys, e => e, BreakingFunc.Of(), - BreakingFunc.Of())); + BreakingFunc.Of()), + Throws.Nothing); } [Test] @@ -44,11 +45,12 @@ public void LeftJoinWithHomogeneousSequencesWithComparerIsLazy() var xs = new BreakingSequence(); var ys = new BreakingSequence(); - Assert.DoesNotThrow(() => + Assert.That(() => xs.LeftJoin(ys, e => e, BreakingFunc.Of(), BreakingFunc.Of(), - comparer: null)); + comparer: null), + Throws.Nothing); } [Test] @@ -57,10 +59,11 @@ public void LeftJoinIsLazy() var xs = new BreakingSequence(); var ys = new BreakingSequence(); - Assert.DoesNotThrow(() => + Assert.That(() => xs.LeftJoin(ys, x => x, y => y.GetHashCode(), BreakingFunc.Of(), - BreakingFunc.Of())); + BreakingFunc.Of()), + Throws.Nothing); } [Test] @@ -69,11 +72,12 @@ public void LeftJoinWithComparerIsLazy() var xs = new BreakingSequence(); var ys = new BreakingSequence(); - Assert.DoesNotThrow(() => + Assert.That(() => xs.LeftJoin(ys, x => x, y => y.GetHashCode(), BreakingFunc.Of(), BreakingFunc.Of(), - comparer: null)); + comparer: null), + Throws.Nothing); } [Test] diff --git a/MoreLinq.Test/MaxByTest.cs b/MoreLinq.Test/MaxByTest.cs index 7cab0440c..59c1bc712 100644 --- a/MoreLinq.Test/MaxByTest.cs +++ b/MoreLinq.Test/MaxByTest.cs @@ -19,7 +19,6 @@ namespace MoreLinq.Test { - using System; using NUnit.Framework; [TestFixture] @@ -85,16 +84,18 @@ public void WithComparerReturnsMaximum() public void WithEmptySourceThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); - Assert.Throws(() => - MoreEnumerable.First(strings.MaxBy(s => s.Length))); + Assert.That(() => + MoreEnumerable.First(strings.MaxBy(s => s.Length)), + Throws.InvalidOperationException); } [Test] public void WithEmptySourceWithComparerThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); - Assert.Throws(() => - MoreEnumerable.First(strings.MaxBy(s => s.Length, Comparable.DescendingOrderComparer))); + Assert.That(() => + MoreEnumerable.First(strings.MaxBy(s => s.Length, Comparable.DescendingOrderComparer)), + Throws.InvalidOperationException); } } @@ -155,16 +156,18 @@ public void WithComparerReturnsMaximumPerComparer() public void WithEmptySourceThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); - Assert.Throws(() => - MoreEnumerable.Last(strings.MaxBy(s => s.Length))); + Assert.That(() => + MoreEnumerable.Last(strings.MaxBy(s => s.Length)), + Throws.InvalidOperationException); } [Test] public void WithEmptySourceWithComparerThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); - Assert.Throws(() => - MoreEnumerable.Last(strings.MaxBy(s => s.Length, Comparable.DescendingOrderComparer))); + Assert.That(() => + MoreEnumerable.Last(strings.MaxBy(s => s.Length, Comparable.DescendingOrderComparer)), + Throws.InvalidOperationException); } } diff --git a/MoreLinq.Test/MemoizeTest.cs b/MoreLinq.Test/MemoizeTest.cs index 80efcabf4..2d94bdf42 100644 --- a/MoreLinq.Test/MemoizeTest.cs +++ b/MoreLinq.Test/MemoizeTest.cs @@ -15,6 +15,10 @@ // limitations under the License. #endregion +// Following warnings are disabled due to false negatives: +#pragma warning disable NUnit2040 // Non-reference types for SameAs constraint +#pragma warning disable NUnit2020 // Incompatible types for SameAs constraint + namespace MoreLinq.Test { using System; @@ -127,13 +131,15 @@ public void MemoizeEnumeratesOnlyOnce() [Test] public void MemoizeDoesNotDisposeOnEarlyExitByDefault() { - Assert.Throws(() => + static void Act() { using var xs = new[] { 1, 2 }.AsTestingSequence(); xs.Memoize().Take(1).Consume(); xs.Memoize().Take(1).Consume(); - }); + } + + Assert.That(Act, Throws.TypeOf()); } [Test] @@ -220,8 +226,9 @@ public static void MemoizeIteratorThrowsWhenCacheDisposedDuringIteration() disposable.Dispose(); - var e = Assert.Throws(() => reader.Read()); - Assert.That(e.ObjectName, Is.EqualTo("MemoizedEnumerable")); + Assert.That(reader.Read, + Throws.ObjectDisposedException + .With.Property(nameof(ObjectDisposedException.ObjectName)).EqualTo("MemoizedEnumerable")); } [Test] @@ -251,13 +258,11 @@ IEnumerable TestSequence() using (var r2 = memoized.Read()) { Assert.That(r1.Read(), Is.EqualTo(r2.Read())); - var e1 = Assert.Throws(() => r1.Read()); - Assert.That(e1, Is.SameAs(error)); + Assert.That(r1.Read, Throws.TypeOf().And.SameAs(error)); Assert.That(xs.IsDisposed, Is.True); - var e2 = Assert.Throws(() => r2.Read()); - Assert.That(e2, Is.SameAs(error)); + Assert.That(r2.Read, Throws.TypeOf().And.SameAs(error)); } using (var r1 = memoized.Read()) Assert.That(r1.Read(), Is.EqualTo(123)); @@ -282,13 +287,9 @@ IEnumerable TestSequence() using (var r1 = memoized.Read()) using (var r2 = memoized.Read()) { - var e1 = Assert.Throws(() => r1.Read()); - Assert.That(e1, Is.SameAs(error)); - + Assert.That(r1.Read, Throws.TypeOf().And.SameAs(error)); Assert.That(xs.IsDisposed, Is.True); - - var e2 = Assert.Throws(() => r2.Read()); - Assert.That(e2, Is.SameAs(error)); + Assert.That(r2.Read, Throws.TypeOf().And.SameAs(error)); } using (var r1 = memoized.Read()) @@ -309,10 +310,7 @@ public void MemoizeRethrowsErrorDuringFirstIterationStartToAllIterationsUntilDis var memo = source.Memoize(); for (var i = 0; i < 2; i++) - { - var e = Assert.Throws(() => memo.First()); - Assert.That(e, Is.SameAs(error)); - } + Assert.That(memo.First, Throws.TypeOf().And.SameAs(error)); ((IDisposable) memo).Dispose(); Assert.That(memo.Single(), Is.EqualTo(obj)); diff --git a/MoreLinq.Test/MinByTest.cs b/MoreLinq.Test/MinByTest.cs index 8482d29b3..d8745c1a6 100644 --- a/MoreLinq.Test/MinByTest.cs +++ b/MoreLinq.Test/MinByTest.cs @@ -19,7 +19,6 @@ namespace MoreLinq.Test { - using System; using NUnit.Framework; [TestFixture] @@ -85,16 +84,16 @@ public void WithComparerReturnsMinimum() public void WithEmptySourceThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); - Assert.Throws(() => - MoreEnumerable.First(strings.MinBy(s => s.Length))); + Assert.That(() => MoreEnumerable.First(strings.MinBy(s => s.Length)), + Throws.InvalidOperationException); } [Test] public void WithEmptySourceWithComparerThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); - Assert.Throws(() => - MoreEnumerable.First(strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer))); + Assert.That(() => MoreEnumerable.First(strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer)), + Throws.InvalidOperationException); } } @@ -155,16 +154,16 @@ public void WithComparerReturnsMinimumPerComparer() public void WithEmptySourceThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); - Assert.Throws(() => - MoreEnumerable.Last(strings.MinBy(s => s.Length))); + Assert.That(() => MoreEnumerable.Last(strings.MinBy(s => s.Length)), + Throws.InvalidOperationException); } [Test] public void WithEmptySourceWithComparerThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); - Assert.Throws(() => - MoreEnumerable.Last(strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer))); + Assert.That(() => MoreEnumerable.Last(strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer)), + Throws.InvalidOperationException); } } diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index 535a85744..c27c04025 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -58,7 +58,7 @@ - + diff --git a/MoreLinq.Test/MoveTest.cs b/MoreLinq.Test/MoveTest.cs index f001a01b7..abe85b2ef 100644 --- a/MoreLinq.Test/MoveTest.cs +++ b/MoreLinq.Test/MoveTest.cs @@ -27,22 +27,22 @@ public class MoveTest [Test] public void MoveWithNegativeFromIndex() { - AssertThrowsArgument.OutOfRangeException("fromIndex", () => - new[] { 1 }.Move(-1, 0, 0)); + Assert.That(() => new[] { 1 }.Move(-1, 0, 0), + Throws.ArgumentOutOfRangeException("fromIndex")); } [Test] public void MoveWithNegativeCount() { - AssertThrowsArgument.OutOfRangeException("count", () => - new[] { 1 }.Move(0, -1, 0)); + Assert.That(() => new[] { 1 }.Move(0, -1, 0), + Throws.ArgumentOutOfRangeException("count")); } [Test] public void MoveWithNegativeToIndex() { - AssertThrowsArgument.OutOfRangeException("toIndex", () => - new[] { 1 }.Move(0, 0, -1)); + Assert.That(() => new[] { 1 }.Move(0, 0, -1), + Throws.ArgumentOutOfRangeException("toIndex")); } [Test] diff --git a/MoreLinq.Test/PadStartTest.cs b/MoreLinq.Test/PadStartTest.cs index a1124712c..2282a28ba 100644 --- a/MoreLinq.Test/PadStartTest.cs +++ b/MoreLinq.Test/PadStartTest.cs @@ -31,7 +31,7 @@ public class PadStartTest [Test] public void PadStartWithNegativeWidth() { - AssertThrowsArgument.Exception("width", () => new int[0].PadStart(-1)); + Assert.That(() => new int[0].PadStart(-1), Throws.ArgumentException("width")); } [Test] @@ -66,7 +66,7 @@ public void ReferenceTypeElements(ICollection source, int width, IEnume [Test] public void PadStartWithPaddingWithNegativeWidth() { - AssertThrowsArgument.Exception("width", () => new int[0].PadStart(-1, 1)); + Assert.That(() => new int[0].PadStart(-1, 1), Throws.ArgumentException("width")); } [Test] @@ -101,7 +101,7 @@ public void ReferenceTypeElements(ICollection source, int width, IEnumer [Test] public void PadStartWithSelectorWithNegativeWidth() { - AssertThrowsArgument.Exception("width", () => new int[0].PadStart(-1, x => x)); + Assert.That(() => new int[0].PadStart(-1, x => x), Throws.ArgumentException("width")); } [Test] diff --git a/MoreLinq.Test/PadTest.cs b/MoreLinq.Test/PadTest.cs index 1c1c2533e..f9677a22d 100644 --- a/MoreLinq.Test/PadTest.cs +++ b/MoreLinq.Test/PadTest.cs @@ -27,8 +27,7 @@ public class PadTest [Test] public void PadNegativeWidth() { - AssertThrowsArgument.Exception("width",() => - new object[0].Pad(-1)); + Assert.That(() => new object[0].Pad(-1), Throws.ArgumentException("width")); } [Test] diff --git a/MoreLinq.Test/PermutationsTest.cs b/MoreLinq.Test/PermutationsTest.cs index 768de6738..67e5c4446 100644 --- a/MoreLinq.Test/PermutationsTest.cs +++ b/MoreLinq.Test/PermutationsTest.cs @@ -63,7 +63,7 @@ public void TestCardinalityTwoPermutation() var permutations = set.Permutations(); // should contain two results: the set itself and its reverse - Assert.IsTrue(permutations.Count() == 2); + Assert.That(permutations.Count(), Is.EqualTo(2)); Assert.That(permutations.First(), Is.EqualTo(set)); Assert.That(permutations.Last(), Is.EqualTo(set.Reverse())); } @@ -90,7 +90,7 @@ public void TestCardinalityThreePermutation() // should contain six permutations (as defined above) Assert.That(permutations.Count(), Is.EqualTo(expectedPermutations.Length)); - Assert.IsTrue(permutations.All(p => expectedPermutations.Contains(p, EqualityComparer.Create>((x, y) => x.SequenceEqual(y))))); + Assert.That(permutations.All(p => expectedPermutations.Contains(p, EqualityComparer.Create>((x, y) => x.SequenceEqual(y)))), Is.True); } /// @@ -133,7 +133,7 @@ public void TestCardinalityFourPermutation() // should contain six permutations (as defined above) Assert.That(permutations.Count(), Is.EqualTo(expectedPermutations.Length)); - Assert.IsTrue(permutations.All(p => expectedPermutations.Contains(p, EqualityComparer.Create>((x, y) => x.SequenceEqual(y))))); + Assert.That(permutations.All(p => expectedPermutations.Contains(p, EqualityComparer.Create>((x, y) => x.SequenceEqual(y)))), Is.True); } /// @@ -185,7 +185,7 @@ public void TestPermutationsAreIndependent() var listPermutations = new List>(); listPermutations.AddRange(permutedSets); - Assert.IsNotEmpty(listPermutations); + Assert.That(listPermutations, Is.Not.Empty); for (var i = 0; i < listPermutations.Count; i++) { diff --git a/MoreLinq.Test/RandomSubsetTest.cs b/MoreLinq.Test/RandomSubsetTest.cs index 7f0e5edf5..265abdbbb 100644 --- a/MoreLinq.Test/RandomSubsetTest.cs +++ b/MoreLinq.Test/RandomSubsetTest.cs @@ -43,8 +43,8 @@ public void TestRandomSubsetIsLazy() [Test] public void TestRandomSubsetNegativeSubsetSize() { - AssertThrowsArgument.OutOfRangeException("subsetSize", () => - Enumerable.Range(1, 10).RandomSubset(-5)); + Assert.That(() => Enumerable.Range(1, 10).RandomSubset(-5), + Throws.ArgumentOutOfRangeException("subsetSize")); } /// @@ -53,8 +53,8 @@ public void TestRandomSubsetNegativeSubsetSize() [Test] public void TestRandomSubsetNegativeSubsetSize2() { - AssertThrowsArgument.OutOfRangeException("subsetSize", () => - Enumerable.Range(1, 10).RandomSubset(-1, new Random())); + Assert.That(() => Enumerable.Range(1, 10).RandomSubset(-1, new Random()), + Throws.ArgumentOutOfRangeException("subsetSize")); } /// @@ -113,10 +113,8 @@ public void TestRandomSubsetLongerThanSequence() const int subsetSize = count + 5; var sequence = Enumerable.Range(1, count); - AssertThrowsArgument.OutOfRangeException("subsetSize", () => - { - sequence.RandomSubset(subsetSize).Consume(); - }); + Assert.That(() => sequence.RandomSubset(subsetSize).Consume(), + Throws.ArgumentOutOfRangeException("subsetSize")); } /// @@ -130,10 +128,8 @@ public void TestRandomSubsetLongerThanSequence2() const int subsetSize = count + 5; var sequence = Enumerable.Range(1, count); - AssertThrowsArgument.OutOfRangeException("subsetSize", () => - { - sequence.RandomSubset(subsetSize, new Random(1234)).Consume(); - }); + Assert.That(() => sequence.RandomSubset(subsetSize, new Random(1234)).Consume(), + Throws.ArgumentOutOfRangeException("subsetSize")); } /// @@ -186,10 +182,10 @@ public void TestRandomSubsetIsUnbiased() // ensure that wth increasing trial size the a RSD% continually decreases for (var j = 0; j < rsdResults.Length - 1; j++) - Assert.Less(rsdResults[j + 1], rsdResults[j]); + Assert.That(rsdResults[j + 1], Is.LessThan(rsdResults[j])); // ensure that the RSD% for the 5M trial size is < 1.0 (this is somewhat arbitrary) - Assert.Less(rsdResults.Last(), 1.0); + Assert.That(rsdResults.Last(), Is.LessThan(1.0)); // for sanity, we output the RSD% values as a cross-check, the expected result should be // that the RSD% rapidly decreases and eventually drops below 1.0 diff --git a/MoreLinq.Test/RandomTest.cs b/MoreLinq.Test/RandomTest.cs index 6cf9f4ab9..3a25d5b4b 100644 --- a/MoreLinq.Test/RandomTest.cs +++ b/MoreLinq.Test/RandomTest.cs @@ -36,10 +36,10 @@ public class RandomTest public void TestNegativeMaxValueException() { const int maxValue = -10; - Assert.Less(maxValue, 0); + Assert.That(maxValue, Is.LessThan(0)); - AssertThrowsArgument.OutOfRangeException("maxValue",() => - MoreEnumerable.Random(maxValue)); + Assert.That(() => MoreEnumerable.Random(maxValue), + Throws.ArgumentOutOfRangeException("maxValue")); } /// @@ -52,10 +52,10 @@ public void TestMinValueGreaterThanMaxValueException() const int minValue = 100; const int maxValue = 10; - Assert.Greater(minValue, maxValue); + Assert.That(minValue, Is.GreaterThan(maxValue)); - AssertThrowsArgument.OutOfRangeException("minValue",() => - MoreEnumerable.Random(minValue, maxValue)); + Assert.That(() => MoreEnumerable.Random(minValue, maxValue), + Throws.ArgumentOutOfRangeException("minValue")); } /// @@ -70,8 +70,8 @@ public void TestRandomDouble() // NOTE: Unclear what should actually be verified here... some additional thought needed. Assert.That(resultA.Count(), Is.EqualTo(RandomTrials)); Assert.That(resultB.Count(), Is.EqualTo(RandomTrials)); - Assert.IsTrue(resultA.All(x => x is >= 0.0 and < 1.0)); - Assert.IsTrue(resultB.All(x => x is >= 0.0 and < 1.0)); + Assert.That(resultA.All(x => x is >= 0.0 and < 1.0), Is.True); + Assert.That(resultB.All(x => x is >= 0.0 and < 1.0), Is.True); } /// @@ -86,8 +86,8 @@ public void TestRandomMaxConstraint() Assert.That(resultA.Count(), Is.EqualTo(RandomTrials)); Assert.That(resultB.Count(), Is.EqualTo(RandomTrials)); - Assert.IsTrue(resultA.All(x => x < max)); - Assert.IsTrue(resultB.All(x => x < max)); + Assert.That(resultA.All(x => x < max), Is.True); + Assert.That(resultB.All(x => x < max), Is.True); } /// @@ -103,8 +103,8 @@ public void TestRandomMinMaxConstraint() Assert.That(resultA.Count(), Is.EqualTo(RandomTrials)); Assert.That(resultB.Count(), Is.EqualTo(RandomTrials)); - Assert.IsTrue(resultA.All(x => x is >= min and < max)); - Assert.IsTrue(resultB.All(x => x is >= min and < max)); + Assert.That(resultA.All(x => x is >= min and < max), Is.True); + Assert.That(resultB.All(x => x is >= min and < max), Is.True); } /// diff --git a/MoreLinq.Test/RepeatTest.cs b/MoreLinq.Test/RepeatTest.cs index 20399644d..12c8b2bf6 100644 --- a/MoreLinq.Test/RepeatTest.cs +++ b/MoreLinq.Test/RepeatTest.cs @@ -62,8 +62,8 @@ public void TestRepeatBehavior() [Test] public void TestNegativeRepeatCount() { - AssertThrowsArgument.OutOfRangeException("count", () => - Enumerable.Range(1, 10).Repeat(-3)); + Assert.That(() => Enumerable.Range(1, 10).Repeat(-3), + Throws.ArgumentOutOfRangeException("count")); } /// @@ -77,7 +77,7 @@ public void TestRepeatForeverBehaviorSingleElementList() var result = sequence.Repeat(); - Assert.IsTrue(result.Take(100).All(x => x == value)); + Assert.That(result.Take(100).All(x => x == value), Is.True); } /// diff --git a/MoreLinq.Test/RightJoinTest.cs b/MoreLinq.Test/RightJoinTest.cs index 9d7076077..a11386a45 100644 --- a/MoreLinq.Test/RightJoinTest.cs +++ b/MoreLinq.Test/RightJoinTest.cs @@ -32,10 +32,11 @@ public void RightJoinWithHomogeneousSequencesIsLazy() var xs = new BreakingSequence(); var ys = new BreakingSequence(); - Assert.DoesNotThrow(() => + Assert.That(() => xs.RightJoin(ys, e => e, BreakingFunc.Of(), - BreakingFunc.Of())); + BreakingFunc.Of()), + Throws.Nothing); } [Test] @@ -44,11 +45,12 @@ public void RightJoinWithHomogeneousSequencesWithComparerIsLazy() var xs = new BreakingSequence(); var ys = new BreakingSequence(); - Assert.DoesNotThrow(() => + Assert.That(() => xs.RightJoin(ys, e => e, BreakingFunc.Of(), BreakingFunc.Of(), - comparer: null)); + comparer: null), + Throws.Nothing); } [Test] @@ -57,10 +59,11 @@ public void RightJoinIsLazy() var xs = new BreakingSequence(); var ys = new BreakingSequence(); - Assert.DoesNotThrow(() => + Assert.That(() => xs.RightJoin(ys, x => x.GetHashCode(), y => y, BreakingFunc.Of(), - BreakingFunc.Of())); + BreakingFunc.Of()), + Throws.Nothing); } [Test] @@ -69,11 +72,12 @@ public void RightJoinWithComparerIsLazy() var xs = new BreakingSequence(); var ys = new BreakingSequence(); - Assert.DoesNotThrow(() => + Assert.That(() => xs.RightJoin(ys, x => x.GetHashCode(), y => y, BreakingFunc.Of(), BreakingFunc.Of(), - comparer: null)); + comparer: null), + Throws.Nothing); } [Test] diff --git a/MoreLinq.Test/ScanByTest.cs b/MoreLinq.Test/ScanByTest.cs index dc263c9e1..343b7bd9d 100644 --- a/MoreLinq.Test/ScanByTest.cs +++ b/MoreLinq.Test/ScanByTest.cs @@ -151,8 +151,8 @@ public void ScanByDoesNotIterateUnnecessaryElements() KeyValuePair.Create('b', 1), KeyValuePair.Create('d', 0)); - Assert.Throws(() => - result.ElementAt(5)); + Assert.That(() => result.ElementAt(5), + Throws.TypeOf()); } } } diff --git a/MoreLinq.Test/ScanTest.cs b/MoreLinq.Test/ScanTest.cs index e94c47dee..15ec08a83 100644 --- a/MoreLinq.Test/ScanTest.cs +++ b/MoreLinq.Test/ScanTest.cs @@ -17,7 +17,6 @@ namespace MoreLinq.Test { - using System; using NUnit.Framework; [TestFixture] @@ -48,7 +47,7 @@ public void ScanDoesNotIterateExtra() { var sequence = Enumerable.Range(1, 3).Concat(new BreakingSequence()).Scan(SampleData.Plus); var gold = new[] {1, 3, 6}; - Assert.Throws(sequence.Consume); + Assert.That(sequence.Consume, Throws.InvalidOperationException); sequence.Take(3).AssertSequenceEqual(gold); } @@ -77,7 +76,7 @@ public void SeededScanDoesNotIterateExtra() { var sequence = Enumerable.Range(1, 3).Concat(new BreakingSequence()).Scan(0, SampleData.Plus); var gold = new[] { 0, 1, 3, 6 }; - Assert.Throws(sequence.Consume); + Assert.That(sequence.Consume, Throws.InvalidOperationException); sequence.Take(4).AssertSequenceEqual(gold); } diff --git a/MoreLinq.Test/SegmentTest.cs b/MoreLinq.Test/SegmentTest.cs index e072ccbd0..44217e0b6 100644 --- a/MoreLinq.Test/SegmentTest.cs +++ b/MoreLinq.Test/SegmentTest.cs @@ -76,7 +76,7 @@ public void TestSegmentIsIdempotent() { for (var i = 0; i < 2; i++) { - Assert.IsTrue(segment.Any()); + Assert.That(segment.Any(), Is.True); Assert.That(segment.Single(), Is.EqualTo(value)); } } @@ -94,9 +94,9 @@ public void TestFirstSegmentNeverEmpty() var resultB = sequence.Segment((_, _) => true); var resultC = sequence.Segment((_, _, _) => true); - Assert.IsTrue(resultA.First().Any()); - Assert.IsTrue(resultB.First().Any()); - Assert.IsTrue(resultC.First().Any()); + Assert.That(resultA.First().Any(), Is.True); + Assert.That(resultB.First().Any(), Is.True); + Assert.That(resultC.First().Any(), Is.True); } /// @@ -110,9 +110,9 @@ public void TestSegmentationStartsWithSecondItem() var resultB = sequence.Segment(BreakingFunc.Of()); var resultC = sequence.Segment(BreakingFunc.Of()); - Assert.IsTrue(resultA.Any()); - Assert.IsTrue(resultB.Any()); - Assert.IsTrue(resultC.Any()); + Assert.That(resultA.Any(), Is.True); + Assert.That(resultB.Any(), Is.True); + Assert.That(resultC.Any(), Is.True); } /// @@ -146,7 +146,7 @@ public void VerifyCanSegmentByPrevious() var result = sequence.Segment((curr, prev, _) => curr != prev); Assert.That(result.Count(), Is.EqualTo(sequence.Distinct().Count())); - Assert.IsTrue(result.All(s => s.Count() == repCount)); + Assert.That(result.All(s => s.Count() == repCount), Is.True); } static IEnumerable Seq(params T[] values) => values; diff --git a/MoreLinq.Test/SequenceTest.cs b/MoreLinq.Test/SequenceTest.cs index 01f49ad16..ad01a274d 100644 --- a/MoreLinq.Test/SequenceTest.cs +++ b/MoreLinq.Test/SequenceTest.cs @@ -134,7 +134,7 @@ public void SequenceWithStepZero(int start, int stop) { var result = MoreEnumerable.Sequence(start, stop, 0); - Assert.IsTrue(result.Take(100).All(x => x == start)); + Assert.That(result.Take(100).All(x => x == start), Is.True); } } } diff --git a/MoreLinq.Test/SliceTest.cs b/MoreLinq.Test/SliceTest.cs index 4cc5efd86..e5fd11c56 100644 --- a/MoreLinq.Test/SliceTest.cs +++ b/MoreLinq.Test/SliceTest.cs @@ -143,7 +143,7 @@ public void TestSliceOptimization(SourceKind sourceKind) var result = sequence.Slice(sliceStart, sliceCount); Assert.That(result.Count(), Is.EqualTo(sliceCount)); - CollectionAssert.AreEqual(Enumerable.Range(5, sliceCount), result); + Assert.That(Enumerable.Range(5, sliceCount), Is.EqualTo(result)); } } } diff --git a/MoreLinq.Test/SortedMergeTest.cs b/MoreLinq.Test/SortedMergeTest.cs index 7c7cae4d3..3ef82578d 100644 --- a/MoreLinq.Test/SortedMergeTest.cs +++ b/MoreLinq.Test/SortedMergeTest.cs @@ -49,8 +49,9 @@ public void TestSortedMergeDisposesOnError() using var sequenceA = TestingSequence.Of(); // Expected and thrown by BreakingSequence - Assert.Throws(() => - sequenceA.SortedMerge(OrderByDirection.Ascending, new BreakingSequence()).Consume()); + Assert.That(() => sequenceA.SortedMerge(OrderByDirection.Ascending, new BreakingSequence()) + .Consume(), + Throws.InvalidOperationException); } /// diff --git a/MoreLinq.Test/StartsWithTest.cs b/MoreLinq.Test/StartsWithTest.cs index 3aeb83e43..99d3f01c0 100644 --- a/MoreLinq.Test/StartsWithTest.cs +++ b/MoreLinq.Test/StartsWithTest.cs @@ -52,13 +52,13 @@ public bool StartsWithWithStrings(string first, string second) [Test] public void StartsWithReturnsTrueIfBothEmpty() { - Assert.True(new int[0].StartsWith(new int[0])); + Assert.That(new int[0].StartsWith(new int[0]), Is.True); } [Test] public void StartsWithReturnsFalseIfOnlyFirstIsEmpty() { - Assert.False(new int[0].StartsWith(new[] {1,2,3})); + Assert.That(new int[0].StartsWith(new[] {1,2,3}), Is.False); } [TestCase("", "", ExpectedResult = true)] @@ -85,10 +85,10 @@ public void StartsWithUsesSpecifiedEqualityComparerOrDefault() var first = new[] {1,2,3}; var second = new[] {4,5,6}; - Assert.False(first.StartsWith(second)); - Assert.False(first.StartsWith(second, null)); - Assert.False(first.StartsWith(second, EqualityComparer.Create(delegate { return false; }))); - Assert.True(first.StartsWith(second, EqualityComparer.Create(delegate { return true; }))); + Assert.That(first.StartsWith(second), Is.False); + Assert.That(first.StartsWith(second, null), Is.False); + Assert.That(first.StartsWith(second, EqualityComparer.Create(delegate { return false; })), Is.False); + Assert.That(first.StartsWith(second, EqualityComparer.Create(delegate { return true; })), Is.True); } [TestCase(SourceKind.BreakingCollection)] @@ -98,7 +98,7 @@ public void StartsWithUsesCollectionsCountToAvoidUnnecessaryIteration(SourceKind var first = new[] { 1, 2 }.ToSourceKind(sourceKind); var second = new[] { 1, 2, 3 }.ToSourceKind(sourceKind); - Assert.False(first.StartsWith(second)); + Assert.That(first.StartsWith(second), Is.False); } } } diff --git a/MoreLinq.Test/SubjectTest.cs b/MoreLinq.Test/SubjectTest.cs index cd571589d..334c82730 100644 --- a/MoreLinq.Test/SubjectTest.cs +++ b/MoreLinq.Test/SubjectTest.cs @@ -36,8 +36,8 @@ static IDisposable Subscribe(IObservable subject, public void SubscribeWithNullObserverThrows() { var subject = new Subject(); - var e = Assert.Throws(() => subject.Subscribe(null)); - Assert.That(e.ParamName, Is.EqualTo("observer")); + Assert.That(() => subject.Subscribe(null), + Throws.ArgumentNullException("observer")); } [Test] diff --git a/MoreLinq.Test/SubsetTest.cs b/MoreLinq.Test/SubsetTest.cs index 201a1ff36..e08174ef8 100644 --- a/MoreLinq.Test/SubsetTest.cs +++ b/MoreLinq.Test/SubsetTest.cs @@ -45,8 +45,8 @@ public void TestNegativeSubsetSize() const int count = 10; var sequence = Enumerable.Range(1, count); - AssertThrowsArgument.OutOfRangeException("subsetSize",() => - sequence.Subsets(-5)); + Assert.That(() => sequence.Subsets(-5), + Throws.ArgumentOutOfRangeException("subsetSize")); } /// @@ -59,10 +59,8 @@ public void TestSubsetLargerThanSequence() var sequence = Enumerable.Range(1, count); var result = sequence.Subsets(count + 5); - AssertThrowsArgument.OutOfRangeException("subsetSize", () => - { - result.Consume(); // this particular exception is deferred until sequence evaluation - }); + Assert.That(result.Consume, // this particular exception is deferred until sequence evaluation + Throws.ArgumentOutOfRangeException("subsetSize")); } /// @@ -90,7 +88,7 @@ public void TestSubsetsInIncreasingOrder() var prevSubset = Enumerable.Empty(); foreach (var subset in result) { - Assert.GreaterOrEqual(subset.Count, prevSubset.Count()); + Assert.That(subset.Count, Is.GreaterThanOrEqualTo(prevSubset.Count())); prevSubset = subset; } } diff --git a/MoreLinq.Test/TakeEveryTest.cs b/MoreLinq.Test/TakeEveryTest.cs index a10d9d5e9..a3fc857cf 100644 --- a/MoreLinq.Test/TakeEveryTest.cs +++ b/MoreLinq.Test/TakeEveryTest.cs @@ -25,15 +25,15 @@ public class TakeEveryTest [Test] public void TakeEveryNegativeSkip() { - AssertThrowsArgument.OutOfRangeException("step",() => - new object[0].TakeEvery(-1)); + Assert.That(() => new object[0].TakeEvery(-1), + Throws.ArgumentOutOfRangeException("step")); } [Test] public void TakeEveryOutOfRangeZeroStep() { - AssertThrowsArgument.OutOfRangeException("step", () => - new object[0].TakeEvery(0)); + Assert.That(() => new object[0].TakeEvery(0), + Throws.ArgumentOutOfRangeException("step")); } [Test] diff --git a/MoreLinq.Test/TestingSequence.cs b/MoreLinq.Test/TestingSequence.cs index 9a6e3ed7f..aa8bf84ee 100644 --- a/MoreLinq.Test/TestingSequence.cs +++ b/MoreLinq.Test/TestingSequence.cs @@ -58,7 +58,7 @@ void AssertDisposed() { if (_disposed == null) return; - Assert.IsTrue(_disposed, "Expected sequence to be disposed."); + Assert.That(_disposed, Is.True, "Expected sequence to be disposed."); _disposed = null; } diff --git a/MoreLinq.Test/Throws.cs b/MoreLinq.Test/Throws.cs new file mode 100644 index 000000000..ef4326408 --- /dev/null +++ b/MoreLinq.Test/Throws.cs @@ -0,0 +1,52 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2022 Atif Aziz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq.Test +{ + using System; + using NUnit.Framework.Constraints; + + static class Throws + { + public static ThrowsNothingConstraint Nothing => NUnit.Framework.Throws.Nothing; + public static ExactTypeConstraint InvalidOperationException => NUnit.Framework.Throws.InvalidOperationException; + public static ExactTypeConstraint ObjectDisposedException => NUnit.Framework.Throws.TypeOf(); + + public static InstanceOfTypeConstraint InstanceOf() + where T : Exception => + NUnit.Framework.Throws.InstanceOf(); + + public static ExactTypeConstraint TypeOf() + where T : Exception => + NUnit.Framework.Throws.TypeOf(); + + public static EqualConstraint ArgumentException(string expectedParamName) => + NUnit.Framework.Throws.ArgumentException.With.ParamName().EqualTo(expectedParamName); + + public static EqualConstraint ArgumentNullException(string expectedParamName) => + NUnit.Framework.Throws.ArgumentNullException.With.ParamName().EqualTo(expectedParamName); + + public static ExactTypeConstraint ArgumentOutOfRangeException() => + NUnit.Framework.Throws.TypeOf(); + + public static EqualConstraint ArgumentOutOfRangeException(string expectedParamName) => + ArgumentOutOfRangeException().With.ParamName().EqualTo(expectedParamName); + + static ResolvableConstraintExpression ParamName(this ConstraintExpression constraint) => + constraint.Property(nameof(System.ArgumentException.ParamName)); + } +} diff --git a/MoreLinq.Test/ToArrayByIndexTest.cs b/MoreLinq.Test/ToArrayByIndexTest.cs index f5f06fb89..27d3567c4 100644 --- a/MoreLinq.Test/ToArrayByIndexTest.cs +++ b/MoreLinq.Test/ToArrayByIndexTest.cs @@ -68,11 +68,11 @@ public void ToArrayByIndexWithBadIndexSelectorThrows() { var input = new[] { 42 }; - Assert.Throws(() => - input.ToArrayByIndex(_ => -1)); + Assert.That(() => input.ToArrayByIndex(_ => -1), + Throws.TypeOf()); - Assert.Throws(() => - input.ToArrayByIndex(_ => -1, BreakingFunc.Of())); + Assert.That(() => input.ToArrayByIndex(_ => -1, BreakingFunc.Of()), + Throws.TypeOf()); } [TestCase(10, -1)] @@ -80,11 +80,11 @@ public void ToArrayByIndexWithBadIndexSelectorThrows() public void ToArrayByIndexWithLengthWithBadIndexSelectorThrows(int length, int badIndex) { var input = new[] { 42 }; - Assert.Throws(() => - input.ToArrayByIndex(length, _ => badIndex)); + Assert.That(() => input.ToArrayByIndex(length, _ => badIndex), + Throws.TypeOf()); - Assert.Throws(() => - input.ToArrayByIndex(10, _ => -1, BreakingFunc.Of())); + Assert.That(() => input.ToArrayByIndex(10, _ => -1, BreakingFunc.Of()), + Throws.TypeOf()); } [Test] diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs index f095a93a3..13e3bf825 100644 --- a/MoreLinq.Test/ToDataTableTest.cs +++ b/MoreLinq.Test/ToDataTableTest.cs @@ -69,8 +69,8 @@ public void ToDataTableNullMemberExpressionMethod() { Expression> expression = null; - AssertThrowsArgument.Exception("expressions",() => - _testObjects.ToDataTable(expression)); + Assert.That(() => _testObjects.ToDataTable(expression), + Throws.ArgumentException("expressions")); } [Test] @@ -79,8 +79,8 @@ public void ToDataTableTableWithWrongColumnNames() var dt = new DataTable(); dt.Columns.Add("Test"); - AssertThrowsArgument.Exception("table",() => - _testObjects.ToDataTable(dt)); + Assert.That(() => _testObjects.ToDataTable(dt), + Throws.ArgumentException("table")); } [Test] @@ -89,37 +89,37 @@ public void ToDataTableTableWithWrongColumnDataType() var dt = new DataTable(); dt.Columns.Add("AString", typeof(int)); - AssertThrowsArgument.Exception("table",() => - _testObjects.ToDataTable(dt, t=>t.AString)); + Assert.That(() => _testObjects.ToDataTable(dt, t=>t.AString), + Throws.ArgumentException("table")); } [Test] public void ToDataTableMemberExpressionMethod() { - AssertThrowsArgument.Exception("lambda", () => - _testObjects.ToDataTable(t => t.ToString())); + Assert.That(() => _testObjects.ToDataTable(t => t.ToString()), + Throws.ArgumentException("lambda")); } [Test] public void ToDataTableMemberExpressionNonMember() { - AssertThrowsArgument.Exception("lambda", () => - _testObjects.ToDataTable(t => t.ToString().Length)); + Assert.That(() => _testObjects.ToDataTable(t => t.ToString().Length), + Throws.ArgumentException("lambda")); } [Test] public void ToDataTableMemberExpressionIndexer() { - AssertThrowsArgument.Exception("lambda",() => - _testObjects.ToDataTable(t => t[0])); + Assert.That(() => _testObjects.ToDataTable(t => t[0]), + Throws.ArgumentException("lambda")); } [Test] public void ToDataTableMemberExpressionStatic() { - AssertThrowsArgument.Exception("lambda", () => - _ = _testObjects.ToDataTable(_ => DateTime.Now)); + Assert.That(() => _ = _testObjects.ToDataTable(_ => DateTime.Now), + Throws.ArgumentException("lambda")); } [Test] @@ -140,7 +140,7 @@ public void ToDataTableSchemaInDeclarationOrder() Assert.That(dt.Columns[3].Caption, Is.EqualTo("ANullableGuidField")); Assert.That(dt.Columns[3].DataType, Is.EqualTo(typeof(Guid))); - Assert.IsTrue(dt.Columns[3].AllowDBNull); + Assert.That(dt.Columns[3].AllowDBNull, Is.True); Assert.That(dt.Columns.Count, Is.EqualTo(4)); } @@ -202,9 +202,9 @@ public void ToDataTableIgnoresStaticMembers() Assert.That(points.Columns.Count, Is.EqualTo(3)); DataColumn x, y, empty; - Assert.NotNull(x = points.Columns["X"]); - Assert.NotNull(y = points.Columns["Y"]); - Assert.NotNull(empty = points.Columns["IsEmpty"]); + Assert.That(x = points.Columns["X"], Is.Not.Null); + Assert.That(y = points.Columns["Y"], Is.Not.Null); + Assert.That(empty = points.Columns["IsEmpty"], Is.Not.Null); var row = points.Rows.Cast().Single(); Assert.That(row[x], Is.EqualTo(12)); Assert.That(row[y], Is.EqualTo(34)); diff --git a/MoreLinq.Test/TransposeTest.cs b/MoreLinq.Test/TransposeTest.cs index 5bdc2422a..f400a0c7c 100644 --- a/MoreLinq.Test/TransposeTest.cs +++ b/MoreLinq.Test/TransposeTest.cs @@ -38,8 +38,8 @@ public void TransposeWithOneNullRow() using var seq3 = TestingSequence.Of(30, 31, 32); using var matrix = TestingSequence.Of(seq1, seq2, seq3, null); - Assert.Throws(() => - matrix.Transpose().FirstOrDefault()); + Assert.That(() => matrix.Transpose().FirstOrDefault(), + Throws.TypeOf()); } [Test] @@ -174,8 +174,8 @@ public void TransposeConsumesRowsLazily() result.ElementAt(0).AssertSequenceEqual(10, 20, 30); - Assert.Throws(() => - result.ElementAt(1)); + Assert.That(() => result.ElementAt(1), + Throws.TypeOf()); } [Test] @@ -188,8 +188,8 @@ public void TransposeWithErroneousRowDisposesRowIterators() using var row3 = TestingSequence.Of(30, 32); using var matrix = TestingSequence.Of(row1, row2, row3); - Assert.Throws(() => - matrix.Transpose().Consume()); + Assert.That(() => matrix.Transpose().Consume(), + Throws.TypeOf()); } static bool IsPrime(int number) diff --git a/MoreLinq.Test/WindowLeftTest.cs b/MoreLinq.Test/WindowLeftTest.cs index 10a49cfe1..e24cf2dbd 100644 --- a/MoreLinq.Test/WindowLeftTest.cs +++ b/MoreLinq.Test/WindowLeftTest.cs @@ -77,8 +77,8 @@ public void WindowModifiedDoesNotAffectPreviousWindow() [Test] public void WindowLeftWithNegativeWindowSize() { - AssertThrowsArgument.OutOfRangeException("size", () => - Enumerable.Repeat(1, 10).WindowLeft(-5)); + Assert.That(() => Enumerable.Repeat(1, 10).WindowLeft(-5), + Throws.ArgumentOutOfRangeException("size")); } [Test] diff --git a/MoreLinq.Test/WindowRightTest.cs b/MoreLinq.Test/WindowRightTest.cs index 6f2aa27df..57d5f5040 100644 --- a/MoreLinq.Test/WindowRightTest.cs +++ b/MoreLinq.Test/WindowRightTest.cs @@ -77,8 +77,8 @@ public void WindowModifiedDoesNotAffectPreviousWindow() [Test] public void WindowRightWithNegativeWindowSize() { - AssertThrowsArgument.OutOfRangeException("size", () => - Enumerable.Repeat(1, 10).WindowRight(-5)); + Assert.That(() => Enumerable.Repeat(1, 10).WindowRight(-5), + Throws.ArgumentOutOfRangeException("size")); } [Test] diff --git a/MoreLinq.Test/WindowTest.cs b/MoreLinq.Test/WindowTest.cs index e711dba11..fb5c93c97 100644 --- a/MoreLinq.Test/WindowTest.cs +++ b/MoreLinq.Test/WindowTest.cs @@ -87,8 +87,8 @@ public void TestWindowNegativeWindowSizeException() { var sequence = Enumerable.Repeat(1, 10); - AssertThrowsArgument.OutOfRangeException("size", () => - sequence.Window(-5)); + Assert.That(() => sequence.Window(-5), + Throws.ArgumentOutOfRangeException("size")); } /// diff --git a/MoreLinq.Test/ZipLongestTest.cs b/MoreLinq.Test/ZipLongestTest.cs index 5b4e74789..05fbd663c 100644 --- a/MoreLinq.Test/ZipLongestTest.cs +++ b/MoreLinq.Test/ZipLongestTest.cs @@ -80,8 +80,8 @@ public void ZipLongestDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); - Assert.Throws(() => - s1.ZipLongest(new BreakingSequence(), Tuple.Create).Consume()); + Assert.That(() => s1.ZipLongest(new BreakingSequence(), Tuple.Create).Consume(), + Throws.InvalidOperationException); } } } diff --git a/MoreLinq.Test/ZipShortestTest.cs b/MoreLinq.Test/ZipShortestTest.cs index ae7de9f14..9c6c59f04 100644 --- a/MoreLinq.Test/ZipShortestTest.cs +++ b/MoreLinq.Test/ZipShortestTest.cs @@ -19,7 +19,6 @@ namespace MoreLinq.Test { - using System; using NUnit.Framework; using Tuple = System.ValueTuple; @@ -111,8 +110,8 @@ public void ZipShortestDisposesInnerSequencesCaseGetEnumeratorThrows() { using var s1 = TestingSequence.Of(1, 2); - Assert.Throws(() => - s1.ZipShortest(new BreakingSequence(), Tuple.Create).Consume()); + Assert.That(() => s1.ZipShortest(new BreakingSequence(), Tuple.Create).Consume(), + Throws.InvalidOperationException); } } } From 2914136999609d1862cb488abdc3340d3618a105 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 20 Dec 2022 21:16:37 +0100 Subject: [PATCH 015/157] Fix code alignment in "AggregateTest" --- MoreLinq.Test/AggregateTest.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/MoreLinq.Test/AggregateTest.cs b/MoreLinq.Test/AggregateTest.cs index 930522d58..94b6c4ade 100644 --- a/MoreLinq.Test/AggregateTest.cs +++ b/MoreLinq.Test/AggregateTest.cs @@ -52,8 +52,8 @@ from m in typeof(MoreEnumerable).GetMethods(BindingFlags.Public | BindingFlags.S Source = source, Expectation = sum, Instantiation = m.MakeGenericMethod(Enumerable.Repeat(typeof(int), m.GetGenericArguments().Length - 1) - .Append(typeof(int[])) // TResult - .ToArray()), + .Append(typeof(int[])) // TResult + .ToArray()), } into m let rst = m.Instantiation.GetParameters().Last().ParameterType From 79a2794871e65c046f9e9ec79c2f5894ba734736 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 20 Dec 2022 22:57:41 +0100 Subject: [PATCH 016/157] Fix nullability of "Rank" comparer argument This is a squashed merge of PR #913 that adds to #803. --- MoreLinq.Test/RankTest.cs | 2 ++ MoreLinq/Extensions.g.cs | 2 +- MoreLinq/Rank.cs | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/MoreLinq.Test/RankTest.cs b/MoreLinq.Test/RankTest.cs index 1187e408e..5fd0a78db 100644 --- a/MoreLinq.Test/RankTest.cs +++ b/MoreLinq.Test/RankTest.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#nullable enable + namespace MoreLinq.Test { using System; diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index 9e5b16a71..52ed15837 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -4634,7 +4634,7 @@ public static IEnumerable Rank(this IEnumerable source) /// A object that defines comparison semantics for the elements in the sequence /// A sequence of position integers representing the ranks of the corresponding items in the sequence - public static IEnumerable Rank(this IEnumerable source, IComparer comparer) + public static IEnumerable Rank(this IEnumerable source, IComparer? comparer) => MoreEnumerable.Rank(source, comparer); } diff --git a/MoreLinq/Rank.cs b/MoreLinq/Rank.cs index d2c81a382..4e5586382 100644 --- a/MoreLinq/Rank.cs +++ b/MoreLinq/Rank.cs @@ -43,7 +43,7 @@ public static IEnumerable Rank(this IEnumerable source) /// A object that defines comparison semantics for the elements in the sequence /// A sequence of position integers representing the ranks of the corresponding items in the sequence - public static IEnumerable Rank(this IEnumerable source, IComparer comparer) + public static IEnumerable Rank(this IEnumerable source, IComparer? comparer) { return source.RankBy(IdFn, comparer); } From 69cc9315088d2d0a5180a1cd4088e089fb1ae127 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 20 Dec 2022 22:56:01 +0100 Subject: [PATCH 017/157] Fix nullability of "ToDataTable" expressions arg --- MoreLinq.Test/ToDataTableTest.cs | 20 +++++++++++++------- MoreLinq/Extensions.ToDataTable.g.cs | 4 ++-- MoreLinq/ToDataTable.cs | 10 +++++----- 3 files changed, 20 insertions(+), 14 deletions(-) diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs index 13e3bf825..66f9399d1 100644 --- a/MoreLinq.Test/ToDataTableTest.cs +++ b/MoreLinq.Test/ToDataTableTest.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#nullable enable + namespace MoreLinq.Test { using System; @@ -51,6 +53,8 @@ public TestObject(int key) ANullableDecimal = key / 3; AString = "ABCDEFGHIKKLMNOPQRSTUVWXYSZ"; } + + public override string ToString() => nameof(TestObject); } @@ -67,9 +71,9 @@ public ToDataTableTest() [Test] public void ToDataTableNullMemberExpressionMethod() { - Expression> expression = null; + Expression>? expression = null; - Assert.That(() => _testObjects.ToDataTable(expression), + Assert.That(() => _testObjects.ToDataTable(expression!), Throws.ArgumentException("expressions")); } @@ -177,7 +181,7 @@ public void ToDataTableWithSchema() .Cast() .ToArray(); - vars.Select(e => new { Name = e.Key.ToString(), Value = e.Value.ToString() }) + vars.Select(e => new { Name = e.Key.ToString(), Value = e.Value!.ToString() }) .ToDataTable(dt, e => e.Name, e => e.Value); var rows = dt.Rows.Cast().ToArray(); @@ -201,10 +205,12 @@ public void ToDataTableIgnoresStaticMembers() var points = new[] { new Point(12, 34) }.ToDataTable(); Assert.That(points.Columns.Count, Is.EqualTo(3)); - DataColumn x, y, empty; - Assert.That(x = points.Columns["X"], Is.Not.Null); - Assert.That(y = points.Columns["Y"], Is.Not.Null); - Assert.That(empty = points.Columns["IsEmpty"], Is.Not.Null); + var x = points.Columns["X"]; + var y = points.Columns["Y"]; + var empty = points.Columns["IsEmpty"]; + Assert.That(x, Is.Not.Null); + Assert.That(y, Is.Not.Null); + Assert.That(empty, Is.Not.Null); var row = points.Rows.Cast().Single(); Assert.That(row[x], Is.EqualTo(12)); Assert.That(row[y], Is.EqualTo(34)); diff --git a/MoreLinq/Extensions.ToDataTable.g.cs b/MoreLinq/Extensions.ToDataTable.g.cs index 66c6f8931..b9165678e 100644 --- a/MoreLinq/Extensions.ToDataTable.g.cs +++ b/MoreLinq/Extensions.ToDataTable.g.cs @@ -68,7 +68,7 @@ public static DataTable ToDataTable(this IEnumerable source) /// /// This operator uses immediate execution. - public static DataTable ToDataTable(this IEnumerable source, params Expression>[] expressions) + public static DataTable ToDataTable(this IEnumerable source, params Expression>[] expressions) => MoreEnumerable.ToDataTable(source, expressions); /// /// Appends elements in the sequence as rows of a given object. @@ -101,7 +101,7 @@ public static TTable ToDataTable(this IEnumerable source, TTable t /// /// This operator uses immediate execution. - public static TTable ToDataTable(this IEnumerable source, TTable table, params Expression>[] expressions) + public static TTable ToDataTable(this IEnumerable source, TTable table, params Expression>[] expressions) where TTable : DataTable => MoreEnumerable.ToDataTable(source, table, expressions); diff --git a/MoreLinq/ToDataTable.cs b/MoreLinq/ToDataTable.cs index d04c66d3c..793eb6bc5 100644 --- a/MoreLinq/ToDataTable.cs +++ b/MoreLinq/ToDataTable.cs @@ -41,7 +41,7 @@ static partial class MoreEnumerable public static TTable ToDataTable(this IEnumerable source, TTable table) where TTable : DataTable { - return ToDataTable(source, table, EmptyArray>>.Value); + return ToDataTable(source, table, EmptyArray>>.Value); } /// @@ -57,7 +57,7 @@ public static TTable ToDataTable(this IEnumerable source, TTable t /// /// This operator uses immediate execution. - public static DataTable ToDataTable(this IEnumerable source, params Expression>[] expressions) + public static DataTable ToDataTable(this IEnumerable source, params Expression>[] expressions) { return ToDataTable(source, new DataTable(), expressions); } @@ -92,7 +92,7 @@ public static DataTable ToDataTable(this IEnumerable source) /// /// This operator uses immediate execution. - public static TTable ToDataTable(this IEnumerable source, TTable table, params Expression>[] expressions) + public static TTable ToDataTable(this IEnumerable source, TTable table, params Expression>[] expressions) where TTable : DataTable { if (source == null) throw new ArgumentNullException(nameof(source)); @@ -100,7 +100,7 @@ public static TTable ToDataTable(this IEnumerable source, TTable t // TODO disallow null for "expressions" in next major update - expressions ??= EmptyArray>>.Value; + expressions ??= EmptyArray>>.Value; var members = PrepareMemberInfos(expressions).ToArray(); members = BuildOrBindSchema(table, members); @@ -130,7 +130,7 @@ public static TTable ToDataTable(this IEnumerable source, TTable t return table; } - static IEnumerable PrepareMemberInfos(ICollection>> expressions) + static IEnumerable PrepareMemberInfos(ICollection>> expressions) { // // If no lambda expressions supplied then reflect them off the source element type. From a8e13e0416026ea072b48ac7dba9e18a7b27e814 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 3 Jan 2023 18:19:46 +0100 Subject: [PATCH 018/157] Enable nullable context for entire solution This is a squashed merge of PR #915 that adds to #803. --- Directory.Build.props | 1 + MoreLinq.Test/AcquireTest.cs | 12 +-- MoreLinq.Test/AggregateTest.cs | 11 +-- MoreLinq.Test/AppendTest.cs | 2 +- MoreLinq.Test/AssertCountTest.cs | 2 +- MoreLinq.Test/AssertTest.cs | 2 +- MoreLinq.Test/Async/AsyncEnumerable.cs | 26 ++++--- MoreLinq.Test/BatchTest.cs | 12 ++- MoreLinq.Test/BreakingCollection.cs | 2 - MoreLinq.Test/BreakingSequence.cs | 9 ++- MoreLinq.Test/ChooseTest.cs | 2 +- MoreLinq.Test/CompareCountTest.cs | 8 +- MoreLinq.Test/Comparer.cs | 8 +- MoreLinq.Test/CountByTest.cs | 16 ++-- MoreLinq.Test/CountDownTest.cs | 10 +-- MoreLinq.Test/Enumerable.cs | 36 +++++---- MoreLinq.Test/EqualityComparer.cs | 10 +-- MoreLinq.Test/EquiZipTest.cs | 4 +- MoreLinq.Test/FlattenTest.cs | 2 - MoreLinq.Test/FullGroupJoinTest.cs | 2 - MoreLinq.Test/IndexByTest.cs | 21 +++-- MoreLinq.Test/InterleaveTest.cs | 2 +- MoreLinq.Test/LagTest.cs | 2 - MoreLinq.Test/LeadTest.cs | 2 - MoreLinq.Test/MaxByTest.cs | 2 - MoreLinq.Test/MemoizeTest.cs | 4 +- MoreLinq.Test/MinByTest.cs | 2 - MoreLinq.Test/MoreLinq.Test.csproj | 1 + MoreLinq.Test/NullArgumentTest.cs | 78 ++++++++++++------- MoreLinq.Test/OrderByTest.cs | 15 +++- MoreLinq.Test/PadStartTest.cs | 2 - MoreLinq.Test/PadTest.cs | 2 - MoreLinq.Test/PartialSortByTest.cs | 2 - MoreLinq.Test/PartialSortTest.cs | 2 - MoreLinq.Test/PartitionTest.cs | 2 - MoreLinq.Test/PermutationsTest.cs | 10 ++- MoreLinq.Test/PrependTest.cs | 2 +- MoreLinq.Test/RankTest.cs | 2 - MoreLinq.Test/ReturnTest.cs | 8 +- MoreLinq.Test/ScanByTest.cs | 34 ++++---- MoreLinq.Test/ScanTest.cs | 6 +- MoreLinq.Test/SequenceReader.cs | 70 ++++------------- MoreLinq.Test/SortedMergeTest.cs | 4 +- MoreLinq.Test/SubjectTest.cs | 22 +++--- MoreLinq.Test/TestingSequence.cs | 4 +- MoreLinq.Test/Throws.cs | 5 +- MoreLinq.Test/ToDelimitedStringTest.cs | 4 +- MoreLinq.Test/TraceTest.cs | 1 - MoreLinq.Test/TransposeTest.cs | 2 +- MoreLinq.Test/WatchableEnumerator.cs | 6 +- MoreLinq.Test/ZipLongestTest.cs | 4 +- MoreLinq.Test/ZipShortestTest.cs | 4 +- MoreLinq/MoreLinq.csproj | 1 - MoreLinq/Reactive/Subject.cs | 2 - .../MoreLinq.ExtensionsGenerator.csproj | 1 - 55 files changed, 245 insertions(+), 263 deletions(-) diff --git a/Directory.Build.props b/Directory.Build.props index f958a257d..11286bf3d 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -1,6 +1,7 @@ 11 + enable true diff --git a/MoreLinq.Test/AcquireTest.cs b/MoreLinq.Test/AcquireTest.cs index c29d09933..14025320b 100644 --- a/MoreLinq.Test/AcquireTest.cs +++ b/MoreLinq.Test/AcquireTest.cs @@ -26,9 +26,9 @@ public class AcquireTest [Test] public void AcquireAll() { - Disposable a = null; - Disposable b = null; - Disposable c = null; + Disposable? a = null; + Disposable? b = null; + Disposable? c = null; var allocators = MoreEnumerable.From(() => a = new Disposable(), () => b = new Disposable(), @@ -48,9 +48,9 @@ public void AcquireAll() [Test] public void AcquireSome() { - Disposable a = null; - Disposable b = null; - Disposable c = null; + Disposable? a = null; + Disposable? b = null; + Disposable? c = null; var allocators = MoreEnumerable.From(() => a = new Disposable(), () => b = new Disposable(), diff --git a/MoreLinq.Test/AggregateTest.cs b/MoreLinq.Test/AggregateTest.cs index 94b6c4ade..690207c5b 100644 --- a/MoreLinq.Test/AggregateTest.cs +++ b/MoreLinq.Test/AggregateTest.cs @@ -65,10 +65,11 @@ into m AccumulatorCount = (m.Instantiation.GetParameters().Length - 2 /* source + resultSelector */) / 2 /* seed + accumulator */, ResultSelectorType = rst, Parameters = - rst.GetMethod("Invoke") - .GetParameters() - .Select(p => Expression.Parameter(p.ParameterType)) - .ToArray(), + rst.GetMethod("Invoke") is { } invoke + ? invoke.GetParameters() + .Select(p => Expression.Parameter(p.ParameterType)) + .ToArray() + : throw new Exception("""Method "Invoke" not found."""), } into m let resultSelector = @@ -96,7 +97,7 @@ into t select new TestCaseData(t.Method, t.Args).SetName(t.Name).Returns(t.Expectation); [TestCaseSource(nameof(AccumulatorsTestSource), new object[] { nameof(Accumulators), 10 })] - public object Accumulators(MethodInfo method, object[] args) => + public object? Accumulators(MethodInfo method, object[] args) => method.Invoke(null, args); [Test] diff --git a/MoreLinq.Test/AppendTest.cs b/MoreLinq.Test/AppendTest.cs index df46b13c7..580a74875 100644 --- a/MoreLinq.Test/AppendTest.cs +++ b/MoreLinq.Test/AppendTest.cs @@ -46,7 +46,7 @@ public void AppendWithEmptyHeadSequence() public void AppendWithNullTail() { var head = new[] { "first", "second" }; - string tail = null; + string? tail = null; var whole = head.Append(tail); whole.AssertSequenceEqual("first", "second", null); } diff --git a/MoreLinq.Test/AssertCountTest.cs b/MoreLinq.Test/AssertCountTest.cs index a9bf9ca53..b2b165564 100644 --- a/MoreLinq.Test/AssertCountTest.cs +++ b/MoreLinq.Test/AssertCountTest.cs @@ -106,7 +106,7 @@ public void AssertCountIsLazy() [Test] public void AssertCountWithCollectionIsLazy() { - new BreakingCollection(5).AssertCount(0); + new BreakingCollection(new int[5]).AssertCount(0); } [Test] diff --git a/MoreLinq.Test/AssertTest.cs b/MoreLinq.Test/AssertTest.cs index ff77f609f..e5bd40d9e 100644 --- a/MoreLinq.Test/AssertTest.cs +++ b/MoreLinq.Test/AssertTest.cs @@ -49,7 +49,7 @@ public void AssertSequenceWithValidSomeInvalidElements() public void AssertSequenceWithInvalidElementsAndCustomErrorReturningNull() { var source = new[] { 2, 4, 6, 7, 8, 9 }; - Assert.That(() => source.Assert(n => n % 2 == 0, _ => null).Consume(), + Assert.That(() => source.Assert(n => n % 2 == 0, _ => null!).Consume(), Throws.InvalidOperationException); } diff --git a/MoreLinq.Test/Async/AsyncEnumerable.cs b/MoreLinq.Test/Async/AsyncEnumerable.cs index 6fe745988..9e34f492a 100644 --- a/MoreLinq.Test/Async/AsyncEnumerable.cs +++ b/MoreLinq.Test/Async/AsyncEnumerable.cs @@ -141,7 +141,7 @@ public static IAsyncEnumerable Distinct(this IAsyncEnumerable< public static ValueTask ElementAtAsync(this IAsyncEnumerable source, int index) => LinqEnumerable.ElementAtAsync(source, index); - public static ValueTask ElementAtOrDefaultAsync(this IAsyncEnumerable source, int index) => + public static ValueTask ElementAtOrDefaultAsync(this IAsyncEnumerable source, int index) => LinqEnumerable.ElementAtOrDefaultAsync(source, index); public static IAsyncEnumerable Empty() => @@ -159,10 +159,10 @@ public static ValueTask FirstAsync(this IAsyncEnumerable FirstAsync(this IAsyncEnumerable source, Func predicate) => LinqEnumerable.FirstAsync(source, predicate); - public static ValueTask FirstOrDefaultAsync(this IAsyncEnumerable source) => + public static ValueTask FirstOrDefaultAsync(this IAsyncEnumerable source) => LinqEnumerable.FirstOrDefaultAsync(source); - public static ValueTask FirstOrDefaultAsync(this IAsyncEnumerable source, Func predicate) => + public static ValueTask FirstOrDefaultAsync(this IAsyncEnumerable source, Func predicate) => LinqEnumerable.FirstOrDefaultAsync(source, predicate); public static IAsyncEnumerable GroupBy(this IAsyncEnumerable source, Func keySelector, Func, TResult> resultSelector, IEqualityComparer comparer) => @@ -213,10 +213,10 @@ public static ValueTask LastAsync(this IAsyncEnumerable LastAsync(this IAsyncEnumerable source, Func predicate) => LinqEnumerable.LastAsync(source, predicate); - public static ValueTask LastOrDefaultAsync(this IAsyncEnumerable source) => + public static ValueTask LastOrDefaultAsync(this IAsyncEnumerable source) => LinqEnumerable.LastOrDefaultAsync(source); - public static ValueTask LastOrDefaultAsync(this IAsyncEnumerable source, Func predicate) => + public static ValueTask LastOrDefaultAsync(this IAsyncEnumerable source, Func predicate) => LinqEnumerable.LastOrDefaultAsync(source, predicate); public static ValueTask LongCountAsync(this IAsyncEnumerable source) => @@ -411,10 +411,10 @@ public static ValueTask SingleAsync(this IAsyncEnumerable SingleAsync(this IAsyncEnumerable source, Func predicate) => LinqEnumerable.SingleAsync(source, predicate); - public static ValueTask SingleOrDefaultAsync(this IAsyncEnumerable source) => + public static ValueTask SingleOrDefaultAsync(this IAsyncEnumerable source) => LinqEnumerable.SingleOrDefaultAsync(source); - public static ValueTask SingleOrDefaultAsync(this IAsyncEnumerable source, Func predicate) => + public static ValueTask SingleOrDefaultAsync(this IAsyncEnumerable source, Func predicate) => LinqEnumerable.SingleOrDefaultAsync(source, predicate); public static IAsyncEnumerable Skip(this IAsyncEnumerable source, int count) => @@ -510,16 +510,20 @@ public static IOrderedAsyncEnumerable ThenByDescending(t public static ValueTask ToArrayAsync(this IAsyncEnumerable source) => LinqEnumerable.ToArrayAsync(source); - public static ValueTask> ToDictionaryAsync(this IAsyncEnumerable source, Func keySelector) => + public static ValueTask> ToDictionaryAsync(this IAsyncEnumerable source, Func keySelector) + where TKey: notnull => LinqEnumerable.ToDictionaryAsync(source, keySelector); - public static ValueTask> ToDictionaryAsync(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) => + public static ValueTask> ToDictionaryAsync(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) + where TKey: notnull => LinqEnumerable.ToDictionaryAsync(source, keySelector, comparer); - public static ValueTask> ToDictionaryAsync(this IAsyncEnumerable source, Func keySelector, Func elementSelector) => + public static ValueTask> ToDictionaryAsync(this IAsyncEnumerable source, Func keySelector, Func elementSelector) + where TKey: notnull => LinqEnumerable.ToDictionaryAsync(source, keySelector, elementSelector); - public static ValueTask> ToDictionaryAsync(this IAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer) => + public static ValueTask> ToDictionaryAsync(this IAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer) + where TKey: notnull => LinqEnumerable.ToDictionaryAsync(source, keySelector, elementSelector, comparer); public static ValueTask> ToListAsync(this IAsyncEnumerable source) => diff --git a/MoreLinq.Test/BatchTest.cs b/MoreLinq.Test/BatchTest.cs index ef923b9dd..3b50d7426 100644 --- a/MoreLinq.Test/BatchTest.cs +++ b/MoreLinq.Test/BatchTest.cs @@ -339,7 +339,7 @@ public void BatchBucketSelectorCurrentList() { var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9); using var pool = new TestArrayPool(); - int[] bucketSelectorItems = null; + int[]? bucketSelectorItems = null; var result = input.Batch(4, pool, current => bucketSelectorItems = current.ToArray(), _ => 0); @@ -356,18 +356,16 @@ public void BatchBucketSelectorCurrentList() sealed class TestArrayPool : ArrayPool, IDisposable { - T[] _pooledArray; - T[] _rentedArray; + T[]? _pooledArray; + T[]? _rentedArray; public override T[] Rent(int minimumLength) { if (_pooledArray is null && _rentedArray is null) _pooledArray = new T[minimumLength * 2]; - if (_pooledArray is null) - throw new InvalidOperationException("The pool is exhausted."); - - (_pooledArray, _rentedArray) = (null, _pooledArray); + (_pooledArray, _rentedArray) = + (null, _pooledArray ?? throw new InvalidOperationException("The pool is exhausted.")); return _rentedArray; } diff --git a/MoreLinq.Test/BreakingCollection.cs b/MoreLinq.Test/BreakingCollection.cs index a628424cf..7cb34e6b9 100644 --- a/MoreLinq.Test/BreakingCollection.cs +++ b/MoreLinq.Test/BreakingCollection.cs @@ -26,8 +26,6 @@ class BreakingCollection : BreakingSequence, ICollection public BreakingCollection(params T[] values) : this ((IList) values) {} public BreakingCollection(IList list) => List = list; - public BreakingCollection(int count) : - this(Enumerable.Repeat(default(T), count).ToList()) {} public int Count => List.Count; diff --git a/MoreLinq.Test/BreakingSequence.cs b/MoreLinq.Test/BreakingSequence.cs index 9ed0ccaae..c3c223311 100644 --- a/MoreLinq.Test/BreakingSequence.cs +++ b/MoreLinq.Test/BreakingSequence.cs @@ -27,7 +27,14 @@ namespace MoreLinq.Test /// class BreakingSequence : IEnumerable { - public IEnumerator GetEnumerator() => throw new InvalidOperationException(); + public IEnumerator GetEnumerator() => throw new BreakException(); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } + + sealed class BreakException : Exception + { + public BreakException() { } + public BreakException(string message) : base(message) { } + public BreakException(string message, Exception inner) : base(message, inner) { } + } } diff --git a/MoreLinq.Test/ChooseTest.cs b/MoreLinq.Test/ChooseTest.cs index acc4dd112..3f6baf592 100644 --- a/MoreLinq.Test/ChooseTest.cs +++ b/MoreLinq.Test/ChooseTest.cs @@ -67,7 +67,7 @@ static class Option static class Option { - public static readonly (bool IsSome, T Value) None = (false, default); + public static readonly (bool IsSome, T Value) None = default; } [Test] diff --git a/MoreLinq.Test/CompareCountTest.cs b/MoreLinq.Test/CompareCountTest.cs index bc93e08de..906749bf6 100644 --- a/MoreLinq.Test/CompareCountTest.cs +++ b/MoreLinq.Test/CompareCountTest.cs @@ -53,7 +53,7 @@ public void CompareCountWithCollectionAndSequence(int collectionCount, int expectedCompareCount, int expectedMoveNextCallCount) { - var collection = new BreakingCollection(collectionCount); + var collection = new BreakingCollection(new int[collectionCount]); using var seq = Enumerable.Range(0, sequenceCount).AsTestingSequence(); @@ -70,7 +70,7 @@ public void CompareCountWithSequenceAndCollection(int sequenceCount, int expectedCompareCount, int expectedMoveNextCallCount) { - var collection = new BreakingCollection(collectionCount); + var collection = new BreakingCollection(new int[collectionCount]); using var seq = Enumerable.Range(0, sequenceCount).AsTestingSequence(); @@ -107,7 +107,7 @@ public void CompareCountDisposesSequenceEnumerators() [Test] public void CompareCountDisposesFirstEnumerator() { - var collection = new BreakingCollection(0); + var collection = new BreakingCollection(); using var seq = TestingSequence.Of(); @@ -117,7 +117,7 @@ public void CompareCountDisposesFirstEnumerator() [Test] public void CompareCountDisposesSecondEnumerator() { - var collection = new BreakingCollection(0); + var collection = new BreakingCollection(); using var seq = TestingSequence.Of(); diff --git a/MoreLinq.Test/Comparer.cs b/MoreLinq.Test/Comparer.cs index 75983a3d2..7f9f26c29 100644 --- a/MoreLinq.Test/Comparer.cs +++ b/MoreLinq.Test/Comparer.cs @@ -27,19 +27,19 @@ sealed class Comparer /// . /// - public static IComparer Create(Func compare) => + public static IComparer Create(Func compare) => new DelegatingComparer(compare); sealed class DelegatingComparer : IComparer { - readonly Func _comparer; + readonly Func _comparer; - public DelegatingComparer(Func comparer) + public DelegatingComparer(Func comparer) { _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer)); } - public int Compare(T x, T y) => _comparer(x, y); + public int Compare(T? x, T? y) => _comparer(x, y); } } } diff --git a/MoreLinq.Test/CountByTest.cs b/MoreLinq.Test/CountByTest.cs index ea0e7e8a1..f0732a7ba 100644 --- a/MoreLinq.Test/CountByTest.cs +++ b/MoreLinq.Test/CountByTest.cs @@ -98,10 +98,10 @@ public void CountByWithSomeNullKeys() var result = ss.CountBy(s => s); result.AssertSequenceEqual( - KeyValuePair.Create("foo", 2), - KeyValuePair.Create((string) null, 4), - KeyValuePair.Create("bar", 2), - KeyValuePair.Create("baz", 2)); + KeyValuePair.Create((string?)"foo", 2), + KeyValuePair.Create((string?)null, 4), + KeyValuePair.Create((string?)"bar", 2), + KeyValuePair.Create((string?)"baz", 2)); } [Test] @@ -110,10 +110,10 @@ public void CountByWithSomeNullKeysAndEqualityComparer() var result = new[] { "a", "B", null, "c", "A", null, "b", "A" }.CountBy(c => c, StringComparer.OrdinalIgnoreCase); result.AssertSequenceEqual( - KeyValuePair.Create("a", 3), - KeyValuePair.Create("B", 2), - KeyValuePair.Create((string)null, 2), - KeyValuePair.Create("c", 1)); + KeyValuePair.Create((string?)"a", 3), + KeyValuePair.Create((string?)"B", 2), + KeyValuePair.Create((string?)null, 2), + KeyValuePair.Create((string?)"c", 1)); } } } diff --git a/MoreLinq.Test/CountDownTest.cs b/MoreLinq.Test/CountDownTest.cs index 1e42f40ea..a1862116e 100644 --- a/MoreLinq.Test/CountDownTest.cs +++ b/MoreLinq.Test/CountDownTest.cs @@ -133,14 +133,14 @@ static class TestCollection { public static ICollection Create(ICollection collection, - Func, IEnumerator> em = null) + Func, IEnumerator>? em = null) { return new Collection(collection, em); } public static IReadOnlyCollection CreateReadOnly(ICollection collection, - Func, IEnumerator> em = null) + Func, IEnumerator>? em = null) { return new ReadOnlyCollection(collection, em); } @@ -154,7 +154,7 @@ abstract class Sequence : IEnumerable { readonly Func, IEnumerator> _em; - protected Sequence(Func, IEnumerator> em) => + protected Sequence(Func, IEnumerator>? em) => _em = em ?? (e => e); public IEnumerator GetEnumerator() => @@ -175,7 +175,7 @@ sealed class Collection : Sequence, ICollection readonly ICollection _collection; public Collection(ICollection collection, - Func, IEnumerator> em = null) : + Func, IEnumerator>? em = null) : base(em) => _collection = collection ?? throw new ArgumentNullException(nameof(collection)); @@ -202,7 +202,7 @@ sealed class ReadOnlyCollection : Sequence, IReadOnlyCollection readonly ICollection _collection; public ReadOnlyCollection(ICollection collection, - Func, IEnumerator> em = null) : + Func, IEnumerator>? em = null) : base(em) => _collection = collection ?? throw new ArgumentNullException(nameof(collection)); diff --git a/MoreLinq.Test/Enumerable.cs b/MoreLinq.Test/Enumerable.cs index 0d6f188d3..f7795af4e 100644 --- a/MoreLinq.Test/Enumerable.cs +++ b/MoreLinq.Test/Enumerable.cs @@ -126,7 +126,7 @@ public static int Count(this IEnumerable source, Func(this IEnumerable source) => LinqEnumerable.Count(source); - public static IEnumerable DefaultIfEmpty(this IEnumerable source) => + public static IEnumerable DefaultIfEmpty(this IEnumerable source) => LinqEnumerable.DefaultIfEmpty(source); public static IEnumerable DefaultIfEmpty(this IEnumerable source, TSource defaultValue) => @@ -141,7 +141,7 @@ public static IEnumerable Distinct(this IEnumerable s public static TSource ElementAt(this IEnumerable source, int index) => LinqEnumerable.ElementAt(source, index); - public static TSource ElementAtOrDefault(this IEnumerable source, int index) => + public static TSource? ElementAtOrDefault(this IEnumerable source, int index) => LinqEnumerable.ElementAtOrDefault(source, index); public static IEnumerable Empty() => @@ -159,10 +159,10 @@ public static TSource First(this IEnumerable source) => public static TSource First(this IEnumerable source, Func predicate) => LinqEnumerable.First(source, predicate); - public static TSource FirstOrDefault(this IEnumerable source) => + public static TSource? FirstOrDefault(this IEnumerable source) => LinqEnumerable.FirstOrDefault(source); - public static TSource FirstOrDefault(this IEnumerable source, Func predicate) => + public static TSource? FirstOrDefault(this IEnumerable source, Func predicate) => LinqEnumerable.FirstOrDefault(source, predicate); public static IEnumerable GroupBy(this IEnumerable source, Func keySelector, Func, TResult> resultSelector, IEqualityComparer comparer) => @@ -213,10 +213,10 @@ public static TSource Last(this IEnumerable source) => public static TSource Last(this IEnumerable source, Func predicate) => LinqEnumerable.Last(source, predicate); - public static TSource LastOrDefault(this IEnumerable source) => + public static TSource? LastOrDefault(this IEnumerable source) => LinqEnumerable.LastOrDefault(source); - public static TSource LastOrDefault(this IEnumerable source, Func predicate) => + public static TSource? LastOrDefault(this IEnumerable source, Func predicate) => LinqEnumerable.LastOrDefault(source, predicate); public static long LongCount(this IEnumerable source) => @@ -249,13 +249,13 @@ public static decimal Max(this IEnumerable source, Func(this IEnumerable source, Func selector) => LinqEnumerable.Max(source, selector); - public static TResult Max(this IEnumerable source, Func selector) => + public static TResult? Max(this IEnumerable source, Func selector) => LinqEnumerable.Max(source, selector); public static double? Max(this IEnumerable source, Func selector) => LinqEnumerable.Max(source, selector); - public static TSource Max(this IEnumerable source) => + public static TSource? Max(this IEnumerable source) => LinqEnumerable.Max(source); public static float Max(this IEnumerable source, Func selector) => @@ -303,7 +303,7 @@ public static long Min(this IEnumerable source, Func(this IEnumerable source, Func selector) => LinqEnumerable.Min(source, selector); - public static TResult Min(this IEnumerable source, Func selector) => + public static TResult? Min(this IEnumerable source, Func selector) => LinqEnumerable.Min(source, selector); public static long? Min(this IEnumerable source, Func selector) => @@ -321,7 +321,7 @@ public static decimal Min(this IEnumerable source, Func(this IEnumerable source, Func selector) => LinqEnumerable.Min(source, selector); - public static TSource Min(this IEnumerable source) => + public static TSource? Min(this IEnumerable source) => LinqEnumerable.Min(source); public static double Min(this IEnumerable source, Func selector) => @@ -411,10 +411,10 @@ public static TSource Single(this IEnumerable source) => public static TSource Single(this IEnumerable source, Func predicate) => LinqEnumerable.Single(source, predicate); - public static TSource SingleOrDefault(this IEnumerable source) => + public static TSource? SingleOrDefault(this IEnumerable source) => LinqEnumerable.SingleOrDefault(source); - public static TSource SingleOrDefault(this IEnumerable source, Func predicate) => + public static TSource? SingleOrDefault(this IEnumerable source, Func predicate) => LinqEnumerable.SingleOrDefault(source, predicate); public static IEnumerable Skip(this IEnumerable source, int count) => @@ -510,16 +510,20 @@ public static IOrderedEnumerable ThenByDescending(this I public static TSource[] ToArray(this IEnumerable source) => LinqEnumerable.ToArray(source); - public static Dictionary ToDictionary(this IEnumerable source, Func keySelector) => + public static Dictionary ToDictionary(this IEnumerable source, Func keySelector) + where TKey : notnull => LinqEnumerable.ToDictionary(source, keySelector); - public static Dictionary ToDictionary(this IEnumerable source, Func keySelector, IEqualityComparer comparer) => + public static Dictionary ToDictionary(this IEnumerable source, Func keySelector, IEqualityComparer comparer) + where TKey : notnull => LinqEnumerable.ToDictionary(source, keySelector, comparer); - public static Dictionary ToDictionary(this IEnumerable source, Func keySelector, Func elementSelector) => + public static Dictionary ToDictionary(this IEnumerable source, Func keySelector, Func elementSelector) + where TKey : notnull => LinqEnumerable.ToDictionary(source, keySelector, elementSelector); - public static Dictionary ToDictionary(this IEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer) => + public static Dictionary ToDictionary(this IEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer) + where TKey : notnull => LinqEnumerable.ToDictionary(source, keySelector, elementSelector, comparer); public static List ToList(this IEnumerable source) => diff --git a/MoreLinq.Test/EqualityComparer.cs b/MoreLinq.Test/EqualityComparer.cs index f377a819c..655999130 100644 --- a/MoreLinq.Test/EqualityComparer.cs +++ b/MoreLinq.Test/EqualityComparer.cs @@ -27,24 +27,24 @@ static class EqualityComparer /// . /// - public static IEqualityComparer Create(Func comparer) => + public static IEqualityComparer Create(Func comparer) => new DelegatingComparer(comparer); sealed class DelegatingComparer : IEqualityComparer { - readonly Func _comparer; + readonly Func _comparer; readonly Func _hasher; - public DelegatingComparer(Func comparer) + public DelegatingComparer(Func comparer) : this(comparer, x => x == null ? 0 : x.GetHashCode()) {} - DelegatingComparer(Func comparer, Func hasher) + DelegatingComparer(Func comparer, Func hasher) { _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer)); _hasher = hasher ?? throw new ArgumentNullException(nameof(hasher)); } - public bool Equals(T x, T y) => _comparer(x, y); + public bool Equals(T? x, T? y) => _comparer(x, y); public int GetHashCode(T obj) => _hasher(obj); } } diff --git a/MoreLinq.Test/EquiZipTest.cs b/MoreLinq.Test/EquiZipTest.cs index c0d18b0af..477a86384 100644 --- a/MoreLinq.Test/EquiZipTest.cs +++ b/MoreLinq.Test/EquiZipTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using NUnit.Framework; @@ -98,7 +96,7 @@ public void ZipDisposesInnerSequencesCaseGetEnumeratorThrows() using var s1 = TestingSequence.Of(1, 2); Assert.That(() => s1.EquiZip(new BreakingSequence(), Tuple.Create).Consume(), - Throws.InvalidOperationException); + Throws.BreakException); } } } diff --git a/MoreLinq.Test/FlattenTest.cs b/MoreLinq.Test/FlattenTest.cs index 2cbbdb940..e1a8a5419 100644 --- a/MoreLinq.Test/FlattenTest.cs +++ b/MoreLinq.Test/FlattenTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using System.Collections.Generic; diff --git a/MoreLinq.Test/FullGroupJoinTest.cs b/MoreLinq.Test/FullGroupJoinTest.cs index 9a73c6ba9..f5435cfa5 100644 --- a/MoreLinq.Test/FullGroupJoinTest.cs +++ b/MoreLinq.Test/FullGroupJoinTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using System; diff --git a/MoreLinq.Test/IndexByTest.cs b/MoreLinq.Test/IndexByTest.cs index da62a738a..8b71ea268 100644 --- a/MoreLinq.Test/IndexByTest.cs +++ b/MoreLinq.Test/IndexByTest.cs @@ -81,18 +81,17 @@ public void IndexByWithSomeNullKeys() var source = new[] { "foo", null, "bar", "baz", null, null, "baz", "bar", null, "foo" }; var result = source.IndexBy(c => c); - const string @null = null; // type inference happiness result.AssertSequenceEqual( - KeyValuePair.Create(0, "foo"), - KeyValuePair.Create(0, @null), - KeyValuePair.Create(0, "bar"), - KeyValuePair.Create(0, "baz"), - KeyValuePair.Create(1, @null), - KeyValuePair.Create(2, @null), - KeyValuePair.Create(1, "baz"), - KeyValuePair.Create(1, "bar"), - KeyValuePair.Create(3, @null), - KeyValuePair.Create(1, "foo")); + KeyValuePair.Create(0, (string?)"foo"), + KeyValuePair.Create(0, (string?)null), + KeyValuePair.Create(0, (string?)"bar"), + KeyValuePair.Create(0, (string?)"baz"), + KeyValuePair.Create(1, (string?)null), + KeyValuePair.Create(2, (string?)null), + KeyValuePair.Create(1, (string?)"baz"), + KeyValuePair.Create(1, (string?)"bar"), + KeyValuePair.Create(3, (string?)null), + KeyValuePair.Create(1, (string?)"foo")); } [Test] diff --git a/MoreLinq.Test/InterleaveTest.cs b/MoreLinq.Test/InterleaveTest.cs index ad9b02c6a..8eecc16a3 100644 --- a/MoreLinq.Test/InterleaveTest.cs +++ b/MoreLinq.Test/InterleaveTest.cs @@ -46,7 +46,7 @@ public void TestInterleaveDisposesOnErrorAtGetEnumerator() // Expected and thrown by BreakingSequence Assert.That(() => sequenceA.Interleave(sequenceB).Consume(), - Throws.InvalidOperationException); + Throws.BreakException); } /// diff --git a/MoreLinq.Test/LagTest.cs b/MoreLinq.Test/LagTest.cs index fbd0262ff..3a1c0fdfd 100644 --- a/MoreLinq.Test/LagTest.cs +++ b/MoreLinq.Test/LagTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using NUnit.Framework; diff --git a/MoreLinq.Test/LeadTest.cs b/MoreLinq.Test/LeadTest.cs index ccff7fb03..39daf7228 100644 --- a/MoreLinq.Test/LeadTest.cs +++ b/MoreLinq.Test/LeadTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using NUnit.Framework; diff --git a/MoreLinq.Test/MaxByTest.cs b/MoreLinq.Test/MaxByTest.cs index 59c1bc712..0abc1beb6 100644 --- a/MoreLinq.Test/MaxByTest.cs +++ b/MoreLinq.Test/MaxByTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using NUnit.Framework; diff --git a/MoreLinq.Test/MemoizeTest.cs b/MoreLinq.Test/MemoizeTest.cs index 2d94bdf42..d600afc68 100644 --- a/MoreLinq.Test/MemoizeTest.cs +++ b/MoreLinq.Test/MemoizeTest.cs @@ -343,13 +343,13 @@ sealed class DisposeTestingSequenceEnumerator : IEnumerator { readonly IEnumerator _sequence; - public event EventHandler Disposed; + public event EventHandler? Disposed; public DisposeTestingSequenceEnumerator(IEnumerator sequence) => _sequence = sequence; public T Current => _sequence.Current; - object IEnumerator.Current => Current; + object? IEnumerator.Current => Current; public void Reset() => _sequence.Reset(); public bool MoveNext() => _sequence.MoveNext(); diff --git a/MoreLinq.Test/MinByTest.cs b/MoreLinq.Test/MinByTest.cs index d8745c1a6..49c8565a7 100644 --- a/MoreLinq.Test/MinByTest.cs +++ b/MoreLinq.Test/MinByTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using NUnit.Framework; diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index c27c04025..ac5c2885c 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -56,6 +56,7 @@ + diff --git a/MoreLinq.Test/NullArgumentTest.cs b/MoreLinq.Test/NullArgumentTest.cs index 8e8d0f36d..dc65ad5ad 100644 --- a/MoreLinq.Test/NullArgumentTest.cs +++ b/MoreLinq.Test/NullArgumentTest.cs @@ -20,12 +20,12 @@ namespace MoreLinq.Test using System; using System.Collections; using System.Collections.Generic; - using System.Diagnostics; using System.Linq.Expressions; using System.Reflection; using System.Threading.Tasks; using NUnit.Framework; using NUnit.Framework.Interfaces; + using StackTrace = System.Diagnostics.StackTrace; [TestFixture] public class NullArgumentTest @@ -41,7 +41,7 @@ public void CanBeNull(Action testCase) => static IEnumerable GetNotNullTestCases() => GetTestCases(canBeNull: false, testCaseFactory: (method, args, paramName) => () => { - Exception e = null; + Exception? e = null; try { @@ -53,24 +53,29 @@ static IEnumerable GetNotNullTestCases() => } Assert.That(e, Is.Not.Null, $"No exception was thrown when {nameof(ArgumentNullException)} was expected."); - Assert.That(e, Is.InstanceOf()); - var ane = (ArgumentNullException) e; - Assert.That(ane.ParamName, Is.EqualTo(paramName)); - var stackTrace = new StackTrace(ane, false); + Assert.That(e, Is.InstanceOf().With.Property(nameof(ArgumentNullException.ParamName)).EqualTo(paramName)); + Debug.Assert(e is not null); + var stackTrace = new StackTrace(e, false); var stackFrame = stackTrace.GetFrames().First(); - var actualType = stackFrame.GetMethod().DeclaringType; +#if NETCOREAPP3_1 + // Under .NET Core 3.1, "StackTrace.GetFrames()" was defined to return an array + // of nullable frame elements. See: + // https://github.com/dotnet/corefx/blob/v3.1.32/src/Common/src/CoreLib/System/Diagnostics/StackTrace.cs#L162 + Debug.Assert(stackFrame is not null); +#endif + var actualType = stackFrame.GetMethod()?.DeclaringType; Assert.That(actualType, Is.SameAs(typeof(MoreEnumerable))); }); static IEnumerable GetCanBeNullTestCases() => GetTestCases(canBeNull: true, testCaseFactory: (method, args, _) => () => method.Invoke(null, args)); - static IEnumerable GetTestCases(bool canBeNull, Func testCaseFactory) => + static IEnumerable GetTestCases(bool canBeNull, Func testCaseFactory) => from m in typeof (MoreEnumerable).GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly) from t in CreateTestCases(m, canBeNull, testCaseFactory) select t; - static IEnumerable CreateTestCases(MethodInfo methodDefinition, bool canBeNull, Func testCaseFactory) + static IEnumerable CreateTestCases(MethodInfo methodDefinition, bool canBeNull, Func testCaseFactory) { var method = InstantiateMethod(methodDefinition); var parameters = method.GetParameters().ToList(); @@ -78,7 +83,7 @@ static IEnumerable CreateTestCases(MethodInfo methodDefinition, b return from param in parameters where IsReferenceType(param) && CanBeNull(param) == canBeNull let arguments = parameters.Select(p => p == param ? null : CreateInstance(p.ParameterType)).ToArray() - let testCase = testCaseFactory(method, arguments, param.Name) + let testCase = testCaseFactory(method, arguments, param.Name ?? throw new NullReferenceException()) let testName = GetTestName(methodDefinition, param) select (ITestCaseData) new TestCaseData(testCase).SetName(testName); } @@ -139,15 +144,25 @@ static object CreateInstance(Type type) if (type == typeof (string)) return ""; if (type == typeof(TaskScheduler)) return TaskScheduler.Default; if (type == typeof(IEnumerable)) return new[] { 1, 2, 3 }; // Provide non-empty sequence for MinBy/MaxBy. - if (type.IsArray) return Array.CreateInstance(type.GetElementType(), 0); - if (type.GetTypeInfo().IsValueType || HasDefaultConstructor(type)) return Activator.CreateInstance(type); if (typeof(Delegate).IsAssignableFrom(type)) return CreateDelegateInstance(type); - var typeInfo = type.GetTypeInfo(); + if (type.IsArray) + { + var elementType = type.GetElementType(); + Debug.Assert(elementType is not null); + return Array.CreateInstance(elementType, 0); + } + + if (type.GetTypeInfo().IsValueType || HasDefaultConstructor(type)) + { + var instance = Activator.CreateInstance(type); + Debug.Assert(instance is not null); + return instance; + } - return typeInfo.IsGenericType - ? CreateGenericInterfaceInstance(typeInfo) - : EmptyEnumerable.Instance; + return type.GetTypeInfo() is { IsGenericType: true } typeInfo + ? CreateGenericInterfaceInstance(typeInfo) + : EmptyEnumerable.Instance; } static bool HasDefaultConstructor(Type type) => @@ -156,6 +171,7 @@ static bool HasDefaultConstructor(Type type) => static Delegate CreateDelegateInstance(Type type) { var invoke = type.GetMethod("Invoke"); + Debug.Assert(invoke is not null); var parameters = invoke.GetParameters().Select(p => Expression.Parameter(p.ParameterType, p.Name)); var body = Expression.Default(invoke.ReturnType); // requires >= .NET 4.0 var lambda = Expression.Lambda(type, body, parameters); @@ -167,8 +183,10 @@ static object CreateGenericInterfaceInstance(TypeInfo type) Debug.Assert(type.IsGenericType && type.IsInterface); var name = type.Name.Substring(1); // Delete first character, i.e. the 'I' in IEnumerable var definition = typeof (GenericArgs).GetTypeInfo().GetNestedType(name); - var instantiation = definition.MakeGenericType(type.GetGenericArguments()); - return Activator.CreateInstance(instantiation); + Debug.Assert(definition is not null); + var instance = Activator.CreateInstance(definition.MakeGenericType(type.GetGenericArguments())); + Debug.Assert(instance is not null); + return instance; } static class EmptyEnumerable @@ -191,45 +209,45 @@ public void Reset() { } // ReSharper disable UnusedMember.Local, UnusedAutoPropertyAccessor.Local static class GenericArgs { - class Enumerator : IEnumerator + class Enumerator : IEnumerator { public bool MoveNext() => false; - public T Current { get; private set; } - object IEnumerator.Current => Current; + public T? Current { get; private set; } + object? IEnumerator.Current => Current; public void Reset() { } public void Dispose() { } } - public class Enumerable : IEnumerable + public class Enumerable : IEnumerable { - public IEnumerator GetEnumerator() => new Enumerator(); + public IEnumerator GetEnumerator() => new Enumerator(); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } - public class OrderedEnumerable : Enumerable, System.Linq.IOrderedEnumerable + public class OrderedEnumerable : Enumerable, System.Linq.IOrderedEnumerable { - public System.Linq.IOrderedEnumerable CreateOrderedEnumerable(Func keySelector, IComparer comparer, bool descending) + public System.Linq.IOrderedEnumerable CreateOrderedEnumerable(Func keySelector, IComparer? comparer, bool descending) { if (keySelector == null) throw new ArgumentNullException(nameof(keySelector)); return this; } } - public class AwaitQuery : Enumerable, - Experimental.IAwaitQuery + public class AwaitQuery : Enumerable, + Experimental.IAwaitQuery { public Experimental.AwaitQueryOptions Options => Experimental.AwaitQueryOptions.Default; - public Experimental.IAwaitQuery WithOptions(Experimental.AwaitQueryOptions options) => this; + public Experimental.IAwaitQuery WithOptions(Experimental.AwaitQueryOptions options) => this; } public class Comparer : IComparer { - public int Compare(T x, T y) => -1; + public int Compare(T? x, T? y) => -1; } public class EqualityComparer : IEqualityComparer { - public bool Equals(T x, T y) => false; + public bool Equals(T? x, T? y) => false; public int GetHashCode(T obj) => 0; } } diff --git a/MoreLinq.Test/OrderByTest.cs b/MoreLinq.Test/OrderByTest.cs index 7cc944c25..cb6f8bf1d 100644 --- a/MoreLinq.Test/OrderByTest.cs +++ b/MoreLinq.Test/OrderByTest.cs @@ -17,6 +17,7 @@ namespace MoreLinq.Test { + using System.Collections.Generic; using NUnit.Framework; /// @@ -45,6 +46,16 @@ public void TestOrderBySelectorPreserved() Assert.That(resultDes1, Is.EqualTo(resultDes2)); } + static readonly IComparer NumericStringComparer = + Comparer.Create((string? a, string? b) => + (a, b) switch + { + (null, null) => 0, + (null, _) => -1, + (_, null) => 1, + var (sa, sb) => int.Parse(sa).CompareTo(int.Parse(sb)) + }); + /// /// Verify that OrderBy preserves the comparer /// @@ -55,7 +66,7 @@ public void TestOrderByComparerPreserved() var sequenceAscending = sequence.Select(x => x.ToString()); var sequenceDescending = sequenceAscending.Reverse(); - var comparer = Comparer.Create((a, b) => int.Parse(a).CompareTo(int.Parse(b))); + var comparer = NumericStringComparer; var resultAsc1 = sequenceAscending.OrderBy(x => x, comparer, OrderByDirection.Descending); var resultAsc2 = sequenceAscending.OrderByDescending(x => x, comparer); @@ -119,7 +130,7 @@ public void TestThenByComparerPreserved() new {A = "2", B = "1"}, }; - var comparer = Comparer.Create((a, b) => int.Parse(a).CompareTo(int.Parse(b))); + var comparer = NumericStringComparer; var resultA1 = sequence.OrderBy(x => x.A, comparer, OrderByDirection.Ascending) .ThenBy(y => y.B, comparer, OrderByDirection.Ascending); diff --git a/MoreLinq.Test/PadStartTest.cs b/MoreLinq.Test/PadStartTest.cs index 2282a28ba..a65e3bd2b 100644 --- a/MoreLinq.Test/PadStartTest.cs +++ b/MoreLinq.Test/PadStartTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using NUnit.Framework; diff --git a/MoreLinq.Test/PadTest.cs b/MoreLinq.Test/PadTest.cs index f9677a22d..4537bdca0 100644 --- a/MoreLinq.Test/PadTest.cs +++ b/MoreLinq.Test/PadTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using NUnit.Framework; diff --git a/MoreLinq.Test/PartialSortByTest.cs b/MoreLinq.Test/PartialSortByTest.cs index 7330a151c..9c83dcd7c 100644 --- a/MoreLinq.Test/PartialSortByTest.cs +++ b/MoreLinq.Test/PartialSortByTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using System; diff --git a/MoreLinq.Test/PartialSortTest.cs b/MoreLinq.Test/PartialSortTest.cs index 53ad4d729..04257a737 100644 --- a/MoreLinq.Test/PartialSortTest.cs +++ b/MoreLinq.Test/PartialSortTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using System; diff --git a/MoreLinq.Test/PartitionTest.cs b/MoreLinq.Test/PartitionTest.cs index 2883885c1..cdc4ac19c 100644 --- a/MoreLinq.Test/PartitionTest.cs +++ b/MoreLinq.Test/PartitionTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using System; diff --git a/MoreLinq.Test/PermutationsTest.cs b/MoreLinq.Test/PermutationsTest.cs index 67e5c4446..11d7d3092 100644 --- a/MoreLinq.Test/PermutationsTest.cs +++ b/MoreLinq.Test/PermutationsTest.cs @@ -90,7 +90,7 @@ public void TestCardinalityThreePermutation() // should contain six permutations (as defined above) Assert.That(permutations.Count(), Is.EqualTo(expectedPermutations.Length)); - Assert.That(permutations.All(p => expectedPermutations.Contains(p, EqualityComparer.Create>((x, y) => x.SequenceEqual(y)))), Is.True); + Assert.That(permutations.All(p => expectedPermutations.Contains(p, SequenceEqualityComparer.Instance)), Is.True); } /// @@ -133,7 +133,7 @@ public void TestCardinalityFourPermutation() // should contain six permutations (as defined above) Assert.That(permutations.Count(), Is.EqualTo(expectedPermutations.Length)); - Assert.That(permutations.All(p => expectedPermutations.Contains(p, EqualityComparer.Create>((x, y) => x.SequenceEqual(y)))), Is.True); + Assert.That(permutations.All(p => expectedPermutations.Contains(p, SequenceEqualityComparer.Instance)), Is.True); } /// @@ -196,5 +196,11 @@ public void TestPermutationsAreIndependent() } } } + + static class SequenceEqualityComparer + { + public static readonly IEqualityComparer> Instance = + EqualityComparer.Create>((x, y) => x is { } sx && y is { } sy && sx.SequenceEqual(sy)); + } } } diff --git a/MoreLinq.Test/PrependTest.cs b/MoreLinq.Test/PrependTest.cs index 381e1deba..a13e3fb77 100644 --- a/MoreLinq.Test/PrependTest.cs +++ b/MoreLinq.Test/PrependTest.cs @@ -46,7 +46,7 @@ public void PrependWithEmptyTailSequence() public void PrependWithNullHead() { string[] tail = { "second", "third" }; - string head = null; + string? head = null; var whole = tail.Prepend(head); whole.AssertSequenceEqual(null, "second", "third"); } diff --git a/MoreLinq.Test/RankTest.cs b/MoreLinq.Test/RankTest.cs index 5fd0a78db..1187e408e 100644 --- a/MoreLinq.Test/RankTest.cs +++ b/MoreLinq.Test/RankTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using System; diff --git a/MoreLinq.Test/ReturnTest.cs b/MoreLinq.Test/ReturnTest.cs index 0cf3f3ee9..29d252632 100644 --- a/MoreLinq.Test/ReturnTest.cs +++ b/MoreLinq.Test/ReturnTest.cs @@ -34,8 +34,8 @@ static class SomeSingleton static class NullSingleton { - public static readonly IEnumerable Sequence = MoreEnumerable.Return(null); - public static IList List => (IList)Sequence; + public static readonly IEnumerable Sequence = MoreEnumerable.Return(null); + public static IList List => (IList)Sequence; } [Test] @@ -77,13 +77,13 @@ public void TestContainsDoesNotThrowWhenTheItemProvidedIsNull() [Test] public void TestIndexOfDoesNotThrowWhenTheItemProvidedIsNull() { - Assert.That(() => NullSingleton.List.IndexOf(new object()), Throws.Nothing); + Assert.That(() => SomeSingleton.List.IndexOf(new object()), Throws.Nothing); } [Test] public void TestIndexOfDoesNotThrowWhenTheItemContainedIsNull() { - Assert.That(() => SomeSingleton.List.IndexOf(null), Throws.Nothing); + Assert.That(() => NullSingleton.List.IndexOf(null), Throws.Nothing); } [Test] diff --git a/MoreLinq.Test/ScanByTest.cs b/MoreLinq.Test/ScanByTest.cs index 343b7bd9d..40414fd3c 100644 --- a/MoreLinq.Test/ScanByTest.cs +++ b/MoreLinq.Test/ScanByTest.cs @@ -50,7 +50,7 @@ public void ScanBy() var result = source.ScanBy( item => item.First(), - key => (Element: default(string), Key: key, State: key - 1), + key => (Element: string.Empty, Key: key, State: key - 1), (state, key, item) => (item, char.ToUpperInvariant(key), state.State + 1)); result.AssertSequenceEqual( @@ -103,31 +103,31 @@ public void ScanByWithSomeNullKeys() var result = source.ScanBy(c => c, _ => -1, (i, _, _) => i + 1); result.AssertSequenceEqual( - KeyValuePair.Create("foo" , 0), - KeyValuePair.Create((string)null, 0), - KeyValuePair.Create("bar" , 0), - KeyValuePair.Create("baz" , 0), - KeyValuePair.Create((string)null, 1), - KeyValuePair.Create((string)null, 2), - KeyValuePair.Create("baz" , 1), - KeyValuePair.Create("bar" , 1), - KeyValuePair.Create((string)null, 3), - KeyValuePair.Create("foo" , 1)); + KeyValuePair.Create((string?)"foo", 0), + KeyValuePair.Create((string?)null , 0), + KeyValuePair.Create((string?)"bar", 0), + KeyValuePair.Create((string?)"baz", 0), + KeyValuePair.Create((string?)null , 1), + KeyValuePair.Create((string?)null , 2), + KeyValuePair.Create((string?)"baz", 1), + KeyValuePair.Create((string?)"bar", 1), + KeyValuePair.Create((string?)null , 3), + KeyValuePair.Create((string?)"foo", 1)); } [Test] public void ScanByWithNullSeed() { - var nil = (object)null; + var nil = (object?)null; var source = new[] { "foo", null, "bar", null, "baz" }; var result = source.ScanBy(c => c, _ => nil, (_, _, _) => nil); result.AssertSequenceEqual( - KeyValuePair.Create("foo" , nil), - KeyValuePair.Create((string)null, nil), - KeyValuePair.Create("bar" , nil), - KeyValuePair.Create((string)null, nil), - KeyValuePair.Create("baz" , nil)); + KeyValuePair.Create((string?)"foo", nil), + KeyValuePair.Create((string?)null , nil), + KeyValuePair.Create((string?)"bar", nil), + KeyValuePair.Create((string?)null , nil), + KeyValuePair.Create((string?)"baz", nil)); } [Test] diff --git a/MoreLinq.Test/ScanTest.cs b/MoreLinq.Test/ScanTest.cs index 15ec08a83..65e6eed10 100644 --- a/MoreLinq.Test/ScanTest.cs +++ b/MoreLinq.Test/ScanTest.cs @@ -47,7 +47,7 @@ public void ScanDoesNotIterateExtra() { var sequence = Enumerable.Range(1, 3).Concat(new BreakingSequence()).Scan(SampleData.Plus); var gold = new[] {1, 3, 6}; - Assert.That(sequence.Consume, Throws.InvalidOperationException); + Assert.That(sequence.Consume, Throws.BreakException); sequence.Take(3).AssertSequenceEqual(gold); } @@ -68,7 +68,7 @@ public void SeededScanSum() [Test] public void SeededScanIsLazy() { - new BreakingSequence().Scan(null, BreakingFunc.Of()); + new BreakingSequence().Scan(null, BreakingFunc.Of()); } [Test] @@ -76,7 +76,7 @@ public void SeededScanDoesNotIterateExtra() { var sequence = Enumerable.Range(1, 3).Concat(new BreakingSequence()).Scan(0, SampleData.Plus); var gold = new[] { 0, 1, 3, 6 }; - Assert.That(sequence.Consume, Throws.InvalidOperationException); + Assert.That(sequence.Consume, Throws.BreakException); sequence.Take(4).AssertSequenceEqual(gold); } diff --git a/MoreLinq.Test/SequenceReader.cs b/MoreLinq.Test/SequenceReader.cs index 1ff809035..5a2a0cba6 100644 --- a/MoreLinq.Test/SequenceReader.cs +++ b/MoreLinq.Test/SequenceReader.cs @@ -35,9 +35,9 @@ public static SequenceReader Read(this IEnumerable source) /// "read" operation. /// /// Type of elements to read. - class SequenceReader : IDisposable + sealed class SequenceReader : IDisposable { - IEnumerator _enumerator; + IEnumerator? _enumerator; /// /// Initializes a instance @@ -63,84 +63,46 @@ static IEnumerator GetEnumerator(IEnumerable source) return source.GetEnumerator(); } + IEnumerator Enumerator => + _enumerator ?? throw new ObjectDisposedException(GetType().FullName); + /// - /// Tires to read the next value. + /// Reads a value otherwise throws + /// if no more values are available. /// - /// - /// When this method returns, contains the value read on success. - /// /// - /// Returns true if a value was successfully read; otherwise, false. + /// Returns the read value; /// - public virtual bool TryRead(out T value) + public T Read() { - EnsureNotDisposed(); + var e = Enumerator; - value = default; - - var e = _enumerator; if (!e.MoveNext()) - return false; + throw new InvalidOperationException(); - value = e.Current; - return true; + return e.Current; } - /// - /// Tires to read the next value otherwise return the default. - /// - - public T TryRead() => TryRead(default); - - /// - /// Tires to read the next value otherwise return a given default. - /// - - public T TryRead(T defaultValue) => - TryRead(out var result) ? result : defaultValue; - - /// - /// Reads a value otherwise throws - /// if no more values are available. - /// - /// - /// Returns the read value; - /// - - public T Read() => - TryRead(out var result) ? result : throw new InvalidOperationException(); - /// /// Reads the end. If the end has not been reached then it /// throws . /// - public virtual void ReadEnd() + public void ReadEnd() { - EnsureNotDisposed(); + var enumerator = Enumerator; - if (_enumerator.MoveNext()) + if (enumerator.MoveNext()) throw new InvalidOperationException(); } - /// - /// Ensures that this object has not been disposed, that - /// has not been previously called. - /// - - protected void EnsureNotDisposed() - { - if (_enumerator == null) - throw new ObjectDisposedException(GetType().FullName); - } - /// /// Disposes this object and enumerator with which is was /// initialized. /// - public virtual void Dispose() + public void Dispose() { var e = _enumerator; if (e == null) return; diff --git a/MoreLinq.Test/SortedMergeTest.cs b/MoreLinq.Test/SortedMergeTest.cs index 3ef82578d..4428e4c5b 100644 --- a/MoreLinq.Test/SortedMergeTest.cs +++ b/MoreLinq.Test/SortedMergeTest.cs @@ -51,7 +51,7 @@ public void TestSortedMergeDisposesOnError() // Expected and thrown by BreakingSequence Assert.That(() => sequenceA.SortedMerge(OrderByDirection.Ascending, new BreakingSequence()) .Consume(), - Throws.InvalidOperationException); + Throws.BreakException); } /// @@ -62,7 +62,7 @@ public void TestSortedMergeComparerNull() { var sequenceA = Enumerable.Range(1, 3); var sequenceB = Enumerable.Range(4, 3); - var result = sequenceA.SortedMerge(OrderByDirection.Ascending, (IComparer)null, sequenceB); + var result = sequenceA.SortedMerge(OrderByDirection.Ascending, (IComparer?)null, sequenceB); Assert.That(result, Is.EqualTo(sequenceA.Concat(sequenceB))); } diff --git a/MoreLinq.Test/SubjectTest.cs b/MoreLinq.Test/SubjectTest.cs index 334c82730..fe44b2485 100644 --- a/MoreLinq.Test/SubjectTest.cs +++ b/MoreLinq.Test/SubjectTest.cs @@ -25,9 +25,9 @@ namespace MoreLinq.Test public class SubjectTest { static IDisposable Subscribe(IObservable subject, - Action onNext = null, - Action onError = null, - Action onCompleted = null) => + Action? onNext = null, + Action? onError = null, + Action? onCompleted = null) => subject.Subscribe(onNext ?? BreakingAction.Of(), onError ?? BreakingAction.Of(), onCompleted ?? BreakingAction.WithoutArguments); @@ -36,7 +36,7 @@ static IDisposable Subscribe(IObservable subject, public void SubscribeWithNullObserverThrows() { var subject = new Subject(); - Assert.That(() => subject.Subscribe(null), + Assert.That(() => subject.Subscribe(null!), Throws.ArgumentNullException("observer")); } @@ -60,8 +60,8 @@ public void OnNextObservations() [Test] public void OnErrorObservations() { - Exception error1 = null; - Exception error2 = null; + Exception? error1 = null; + Exception? error2 = null; var subject = new Subject(); @@ -139,7 +139,7 @@ public void SubscriptionPostCompletion() [Test] public void SubscriptionPostError() { - Exception observedError = null; + Exception? observedError = null; var subject = new Subject(); var error = new TestException(); subject.OnError(error); @@ -215,8 +215,12 @@ public void ErrorsOnce() public void SafeToDisposeDuringOnNext() { var subject = new Subject(); - IDisposable subscription = null; - var action = new Action(() => subscription.Dispose()); + IDisposable? subscription = null; + var action = new Action(() => + { + Debug.Assert(subscription is not null); + subscription.Dispose(); + }); subscription = subject.Subscribe(_ => action()); subject.OnNext(42); action = BreakingAction.WithoutArguments; diff --git a/MoreLinq.Test/TestingSequence.cs b/MoreLinq.Test/TestingSequence.cs index aa8bf84ee..0a90139d2 100644 --- a/MoreLinq.Test/TestingSequence.cs +++ b/MoreLinq.Test/TestingSequence.cs @@ -41,7 +41,7 @@ internal static TestingSequence AsTestingSequence(this IEnumerable sour sealed class TestingSequence : IEnumerable, IDisposable { bool? _disposed; - IEnumerable _sequence; + IEnumerable? _sequence; internal TestingSequence(IEnumerable sequence) => _sequence = sequence; @@ -65,6 +65,8 @@ void AssertDisposed() public IEnumerator GetEnumerator() { Assert.That(_sequence, Is.Not.Null, "LINQ operators should not enumerate a sequence more than once."); + Debug.Assert(_sequence is not null); + var enumerator = _sequence.GetEnumerator().AsWatchable(); _disposed = false; enumerator.Disposed += delegate diff --git a/MoreLinq.Test/Throws.cs b/MoreLinq.Test/Throws.cs index ef4326408..672234e3c 100644 --- a/MoreLinq.Test/Throws.cs +++ b/MoreLinq.Test/Throws.cs @@ -24,7 +24,8 @@ static class Throws { public static ThrowsNothingConstraint Nothing => NUnit.Framework.Throws.Nothing; public static ExactTypeConstraint InvalidOperationException => NUnit.Framework.Throws.InvalidOperationException; - public static ExactTypeConstraint ObjectDisposedException => NUnit.Framework.Throws.TypeOf(); + public static ExactTypeConstraint ObjectDisposedException => TypeOf(); + public static ExactTypeConstraint BreakException => TypeOf(); public static InstanceOfTypeConstraint InstanceOf() where T : Exception => @@ -41,7 +42,7 @@ public static EqualConstraint ArgumentNullException(string expectedParamName) => NUnit.Framework.Throws.ArgumentNullException.With.ParamName().EqualTo(expectedParamName); public static ExactTypeConstraint ArgumentOutOfRangeException() => - NUnit.Framework.Throws.TypeOf(); + TypeOf(); public static EqualConstraint ArgumentOutOfRangeException(string expectedParamName) => ArgumentOutOfRangeException().With.ParamName().EqualTo(expectedParamName); diff --git a/MoreLinq.Test/ToDelimitedStringTest.cs b/MoreLinq.Test/ToDelimitedStringTest.cs index 8d7eb1f0a..61d21e659 100644 --- a/MoreLinq.Test/ToDelimitedStringTest.cs +++ b/MoreLinq.Test/ToDelimitedStringTest.cs @@ -32,7 +32,7 @@ public void ToDelimitedStringWithNonEmptySequenceAndDelimiter() [Test] public void ToDelimitedStringWithNonEmptySequenceContainingNulls() { - var result = new object[] { 1, null, "foo", true }.ToDelimitedString(","); + var result = new object?[] { 1, null, "foo", true }.ToDelimitedString(","); Assert.That(result, Is.EqualTo("1,,foo,True")); } @@ -40,7 +40,7 @@ public void ToDelimitedStringWithNonEmptySequenceContainingNulls() public void ToDelimitedStringWithNonEmptySequenceContainingNullsAtStart() { // See: https://github.com/morelinq/MoreLINQ/issues/43 - var result = new object[] { null, null, "foo" }.ToDelimitedString(","); + var result = new object?[] { null, null, "foo" }.ToDelimitedString(","); Assert.That(result, Is.EqualTo(",,foo")); } } diff --git a/MoreLinq.Test/TraceTest.cs b/MoreLinq.Test/TraceTest.cs index 36a7ca0ed..65dc4f2b3 100644 --- a/MoreLinq.Test/TraceTest.cs +++ b/MoreLinq.Test/TraceTest.cs @@ -84,7 +84,6 @@ static IEnumerable Lines(string str) IEnumerator _(TextReader reader) { - Debug.Assert(reader != null); while (reader.ReadLine() is { } line) yield return line; } diff --git a/MoreLinq.Test/TransposeTest.cs b/MoreLinq.Test/TransposeTest.cs index f400a0c7c..70f3c6772 100644 --- a/MoreLinq.Test/TransposeTest.cs +++ b/MoreLinq.Test/TransposeTest.cs @@ -36,7 +36,7 @@ public void TransposeWithOneNullRow() using var seq1 = TestingSequence.Of(10, 11); using var seq2 = TestingSequence.Of(); using var seq3 = TestingSequence.Of(30, 31, 32); - using var matrix = TestingSequence.Of(seq1, seq2, seq3, null); + using var matrix = TestingSequence.Of>(seq1, seq2, seq3, null!); Assert.That(() => matrix.Transpose().FirstOrDefault(), Throws.TypeOf()); diff --git a/MoreLinq.Test/WatchableEnumerator.cs b/MoreLinq.Test/WatchableEnumerator.cs index ca22e87be..2756df448 100644 --- a/MoreLinq.Test/WatchableEnumerator.cs +++ b/MoreLinq.Test/WatchableEnumerator.cs @@ -31,14 +31,14 @@ sealed class WatchableEnumerator : IEnumerator { readonly IEnumerator _source; - public event EventHandler Disposed; - public event EventHandler MoveNextCalled; + public event EventHandler? Disposed; + public event EventHandler? MoveNextCalled; public WatchableEnumerator(IEnumerator source) => _source = source ?? throw new ArgumentNullException(nameof(source)); public T Current => _source.Current; - object IEnumerator.Current => Current; + object? IEnumerator.Current => Current; public void Reset() => _source.Reset(); public bool MoveNext() diff --git a/MoreLinq.Test/ZipLongestTest.cs b/MoreLinq.Test/ZipLongestTest.cs index 05fbd663c..24bd03a59 100644 --- a/MoreLinq.Test/ZipLongestTest.cs +++ b/MoreLinq.Test/ZipLongestTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using System; @@ -81,7 +79,7 @@ public void ZipLongestDisposesInnerSequencesCaseGetEnumeratorThrows() using var s1 = TestingSequence.Of(1, 2); Assert.That(() => s1.ZipLongest(new BreakingSequence(), Tuple.Create).Consume(), - Throws.InvalidOperationException); + Throws.BreakException); } } } diff --git a/MoreLinq.Test/ZipShortestTest.cs b/MoreLinq.Test/ZipShortestTest.cs index 9c6c59f04..3a63b3660 100644 --- a/MoreLinq.Test/ZipShortestTest.cs +++ b/MoreLinq.Test/ZipShortestTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using NUnit.Framework; @@ -111,7 +109,7 @@ public void ZipShortestDisposesInnerSequencesCaseGetEnumeratorThrows() using var s1 = TestingSequence.Of(1, 2); Assert.That(() => s1.ZipShortest(new BreakingSequence(), Tuple.Create).Consume(), - Throws.InvalidOperationException); + Throws.BreakException); } } } diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index f428cf3e3..dccb0afc0 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -120,7 +120,6 @@ 3.3.2 MoreLINQ Developers. net451;netstandard1.0;netstandard2.0;netstandard2.1;net6.0 - enable false diff --git a/MoreLinq/Reactive/Subject.cs b/MoreLinq/Reactive/Subject.cs index f1fc91a6a..bef962abb 100644 --- a/MoreLinq/Reactive/Subject.cs +++ b/MoreLinq/Reactive/Subject.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Reactive { using System; diff --git a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj index ee274ddfb..e1c9c8e49 100644 --- a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj +++ b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj @@ -3,7 +3,6 @@ Exe net7.0 false - enable From 52f705d2390a26aac4919099621a86e6a6110176 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 12 Jan 2023 21:46:34 +0100 Subject: [PATCH 019/157] Seal (private) enumerators --- MoreLinq/Permutations.cs | 2 +- MoreLinq/Subsets.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs index 0fac1001b..b700e46fc 100644 --- a/MoreLinq/Permutations.cs +++ b/MoreLinq/Permutations.cs @@ -29,7 +29,7 @@ public static partial class MoreEnumerable /// The private implementation class that produces permutations of a sequence. /// - class PermutationEnumerator : IEnumerator> + sealed class PermutationEnumerator : IEnumerator> { // NOTE: The algorithm used to generate permutations uses the fact that any set // can be put into 1-to-1 correspondence with the set of ordinals number (0..n). diff --git a/MoreLinq/Subsets.cs b/MoreLinq/Subsets.cs index 357a60f73..3ddf9f49a 100644 --- a/MoreLinq/Subsets.cs +++ b/MoreLinq/Subsets.cs @@ -123,7 +123,7 @@ sealed class SubsetGenerator : IEnumerable> /// predetermined size less than or equal to the original set size. /// - class SubsetEnumerator : IEnumerator> + sealed class SubsetEnumerator : IEnumerator> { readonly IList _set; // the original set of elements readonly T[] _subset; // the current subset to return From a53d8973e6c54ac81d251373dc71b0616e258a6f Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 12 Jan 2023 21:50:19 +0100 Subject: [PATCH 020/157] Replace "!" with debug assertion in "Permutations" This adds to commit b31c7fdd6b02a77f37e57c0684e6bdcb8b51e5ba, "Replace null-forgiving operator uses with debug assertions (#890)". --- MoreLinq/Permutations.cs | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs index b700e46fc..fd9698468 100644 --- a/MoreLinq/Permutations.cs +++ b/MoreLinq/Permutations.cs @@ -103,7 +103,14 @@ public void Reset() _hasMoreResults = true; // there's always at least one permutation: the original set itself } - public IList Current => _current!; + public IList Current + { + get + { + Debug.Assert(_current is not null); + return _current; + } + } object IEnumerator.Current => Current; From 1fc1e312e8478462cad0e90bde7dc572b344129f Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 14 Jan 2023 13:50:25 +0100 Subject: [PATCH 021/157] Fix typos in comments --- MoreLinq.Test/LeadTest.cs | 2 +- MoreLinq.Test/PartialSortByTest.cs | 2 +- MoreLinq.Test/PartialSortTest.cs | 2 +- MoreLinq.Test/PermutationsTest.cs | 2 +- MoreLinq.Test/RankTest.cs | 2 +- MoreLinq/CountDown.cs | 2 +- MoreLinq/CountMethods.cs | 4 ++-- MoreLinq/Experimental/Await.cs | 8 ++++---- MoreLinq/Experimental/Memoize.cs | 2 +- MoreLinq/Extensions.g.cs | 18 +++++++++--------- MoreLinq/FillBackward.cs | 2 +- MoreLinq/FillForward.cs | 2 +- MoreLinq/FullJoin.cs | 2 +- MoreLinq/LeftJoin.cs | 2 +- MoreLinq/Permutations.cs | 8 ++++---- MoreLinq/Random.cs | 2 +- MoreLinq/RandomSubset.cs | 4 ++-- MoreLinq/RightJoin.cs | 2 +- MoreLinq/ScanRight.cs | 4 ++-- MoreLinq/Subsets.cs | 8 ++++---- MoreLinq/Window.cs | 8 ++++---- 21 files changed, 44 insertions(+), 44 deletions(-) diff --git a/MoreLinq.Test/LeadTest.cs b/MoreLinq.Test/LeadTest.cs index 39daf7228..8b2e245b8 100644 --- a/MoreLinq.Test/LeadTest.cs +++ b/MoreLinq.Test/LeadTest.cs @@ -72,7 +72,7 @@ public void TestLeadExplicitDefaultValue() } /// - /// Verify that Lead() willuse default(T) if a specific default value is not supplied for the lead value. + /// Verify that Lead() will use default(T) if a specific default value is not supplied for the lead value. /// [Test] public void TestLeadImplicitDefaultValue() diff --git a/MoreLinq.Test/PartialSortByTest.cs b/MoreLinq.Test/PartialSortByTest.cs index 9c83dcd7c..e192e60fe 100644 --- a/MoreLinq.Test/PartialSortByTest.cs +++ b/MoreLinq.Test/PartialSortByTest.cs @@ -87,7 +87,7 @@ public void PartialSortByIsStable() var sorted = foobars.PartialSort(5); - // Pair expected and actuals by index and then check + // Pair expected and actual by index and then check // reference equality, finding the first mismatch. var mismatchIndex = diff --git a/MoreLinq.Test/PartialSortTest.cs b/MoreLinq.Test/PartialSortTest.cs index 04257a737..3c644e6ae 100644 --- a/MoreLinq.Test/PartialSortTest.cs +++ b/MoreLinq.Test/PartialSortTest.cs @@ -92,7 +92,7 @@ public void PartialSortByIsStable() var sorted = foobars.PartialSortBy(5, s => s.Length); - // Pair expected and actuals by index and then check + // Pair expected and actual by index and then check // reference equality, finding the first mismatch. var mismatchIndex = diff --git a/MoreLinq.Test/PermutationsTest.cs b/MoreLinq.Test/PermutationsTest.cs index 11d7d3092..231e4c601 100644 --- a/MoreLinq.Test/PermutationsTest.cs +++ b/MoreLinq.Test/PermutationsTest.cs @@ -144,7 +144,7 @@ public void TestCardinalityFourPermutation() public void TestHigherCardinalityPermutations() { // NOTE: Testing higher cardinality permutations by exhaustive comparison becomes tedious - // above cardiality 4 sets, as the number of permutations is N! (factorial). To provide + // above cardinality 4 sets, as the number of permutations is N! (factorial). To provide // some level of verification, though, we will simply test the count of items in the // permuted sets, and verify they are equal to the expected number (count!). diff --git a/MoreLinq.Test/RankTest.cs b/MoreLinq.Test/RankTest.cs index 1187e408e..6965c1226 100644 --- a/MoreLinq.Test/RankTest.cs +++ b/MoreLinq.Test/RankTest.cs @@ -171,7 +171,7 @@ public void TestRankCustomComparer() const int count = 10; var ordinals = Enumerable.Range(1, count); var sequence = ordinals.Select( x => new DateTime(2010,x,20-x) ); - // invert the CompareTo operation to Rank in reverse order (ascening to descending) + // invert the CompareTo operation to Rank in reverse order (ascending to descending) var resultA = sequence.AsTestingSequence().Rank(Comparer.Create((a, b) => -a.CompareTo(b))); var resultB = sequence.AsTestingSequence().RankBy(x => x.Day, Comparer.Create((a, b) => -a.CompareTo(b))); diff --git a/MoreLinq/CountDown.cs b/MoreLinq/CountDown.cs index f95985898..a46186a89 100644 --- a/MoreLinq/CountDown.cs +++ b/MoreLinq/CountDown.cs @@ -39,7 +39,7 @@ static partial class MoreEnumerable /// A function that receives the element and the current countdown /// value for the element and which returns those mapped to a /// result returned in the resulting sequence. For elements before - /// the last , the coundown value is + /// the last , the countdown value is /// null. /// /// A sequence of results returned by diff --git a/MoreLinq/CountMethods.cs b/MoreLinq/CountMethods.cs index fd2cb640e..d253dc7c8 100644 --- a/MoreLinq/CountMethods.cs +++ b/MoreLinq/CountMethods.cs @@ -55,7 +55,7 @@ public static bool AtLeast(this IEnumerable source, int count) /// /// Element type of sequence /// The source sequence - /// The maximun number of items a sequence must have for this + /// The maximum number of items a sequence must have for this /// function to return true /// is null /// is negative @@ -110,7 +110,7 @@ public static bool Exactly(this IEnumerable source, int count) /// The source sequence /// The minimum number of items a sequence must have for this /// function to return true - /// The maximun number of items a sequence must have for this + /// The maximum number of items a sequence must have for this /// function to return true /// is null /// is negative or is less than min diff --git a/MoreLinq/Experimental/Await.cs b/MoreLinq/Experimental/Await.cs index 3873754ea..779a5ed29 100644 --- a/MoreLinq/Experimental/Await.cs +++ b/MoreLinq/Experimental/Await.cs @@ -363,14 +363,14 @@ select e.Task.IsFaulted /// completed task. /// /// The type of the source elements. - /// The type of the tasks's result. + /// The type of the task's result. /// The type of the result elements. /// The source sequence. /// A function to begin the asynchronous /// evaluation of each element, the second parameter of which is a /// that can be used to abort /// asynchronous operations. - /// A fucntion that projects the final + /// A function that projects the final /// result given the source item and its asynchronous completion /// result. /// @@ -483,7 +483,7 @@ void PostNotice(Notice notice, // Note that only the "last" critical error is reported // as maintaining a list would incur allocations. The idea // here is to make a best effort attempt to report any of - // the error conditions that may be occuring, which is still + // the error conditions that may be occurring, which is still // better than nothing. try @@ -656,7 +656,7 @@ void OnPendingCompleted() var item = enumerator.Current; var task = starter(item); - // Add a continutation that notifies completion of the task, + // Add a continuation that notifies completion of the task, // along with the necessary housekeeping, in case it // completes before maximum concurrency is reached. diff --git a/MoreLinq/Experimental/Memoize.cs b/MoreLinq/Experimental/Memoize.cs index cc5e2a09a..258037e9c 100644 --- a/MoreLinq/Experimental/Memoize.cs +++ b/MoreLinq/Experimental/Memoize.cs @@ -44,7 +44,7 @@ static partial class ExperimentalEnumerable /// The returned will cache items from /// in a thread-safe manner. Each thread can /// call its to acquire an - /// iterator but the same iterator should not be used simultanesouly + /// iterator but the same iterator should not be used simultaneously /// from multiple threads. The sequence supplied in is not expected to be thread-safe but it is required /// to be thread-agnostic because different threads (though never diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index 52ed15837..e01aee1d9 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -586,7 +586,7 @@ public static partial class AtMostExtension /// /// Element type of sequence /// The source sequence - /// The maximun number of items a sequence must have for this + /// The maximum number of items a sequence must have for this /// function to return true /// is null /// is negative @@ -1137,7 +1137,7 @@ public static partial class CountBetweenExtension /// The source sequence /// The minimum number of items a sequence must have for this /// function to return true - /// The maximun number of items a sequence must have for this + /// The maximum number of items a sequence must have for this /// function to return true /// is null /// is negative or is less than min @@ -1214,7 +1214,7 @@ public static partial class CountDownExtension /// A function that receives the element and the current countdown /// value for the element and which returns those mapped to a /// result returned in the resulting sequence. For elements before - /// the last , the coundown value is + /// the last , the countdown value is /// null. /// /// A sequence of results returned by @@ -1778,7 +1778,7 @@ public static IEnumerable FillBackward(this IEnumerable source, Func /// Returns a sequence with each missing element in the source replaced /// with the following non-missing element in that sequence. Additional - /// parameters specifiy two functions, one used to determine if an + /// parameters specify two functions, one used to determine if an /// element is considered missing or not and another to provide the /// replacement for the missing element. /// @@ -1855,7 +1855,7 @@ public static IEnumerable FillForward(this IEnumerable source, Func /// Returns a sequence with each missing element in the source replaced /// with one based on the previous non-missing element seen in that - /// sequence. Additional parameters specifiy two functions, one used to + /// sequence. Additional parameters specify two functions, one used to /// determine if an element is considered missing or not and another /// to provide the replacement for the missing element. /// @@ -5034,7 +5034,7 @@ public static IEnumerable> ScanBy - /// Peforms a right-associative scan (inclusive prefix) on a sequence of elements. + /// Performs a right-associative scan (inclusive prefix) on a sequence of elements. /// This operator is the right-associative version of the /// LINQ operator. /// @@ -5060,7 +5060,7 @@ public static IEnumerable ScanRight(this IEnumerable => MoreEnumerable.ScanRight(source, func); /// - /// Peforms a right-associative scan (inclusive prefix) on a sequence of elements. + /// Performs a right-associative scan (inclusive prefix) on a sequence of elements. /// The specified seed value is used as the initial accumulator value. /// This operator is the right-associative version of the /// LINQ operator. @@ -6688,11 +6688,11 @@ public static IEnumerable> Transpose(this IEnumerable - /// Processes a sequence into a series of subsequences representing a windowed subset of the original + /// Processes a sequence into a series of sub-sequences representing a windowed subset of the original /// /// /// The number of sequences returned is: Max(0, sequence.Count() - windowSize) + 1
- /// Returned subsequences are buffered, but the overall operation is streamed.
+ /// Returned sub-sequences are buffered, but the overall operation is streamed.
/// /// The type of the elements of the source sequence /// The sequence to evaluate a sliding window over diff --git a/MoreLinq/FillBackward.cs b/MoreLinq/FillBackward.cs index b7edd86b6..c07c8a81b 100644 --- a/MoreLinq/FillBackward.cs +++ b/MoreLinq/FillBackward.cs @@ -74,7 +74,7 @@ public static IEnumerable FillBackward(this IEnumerable source, Func /// Returns a sequence with each missing element in the source replaced /// with the following non-missing element in that sequence. Additional - /// parameters specifiy two functions, one used to determine if an + /// parameters specify two functions, one used to determine if an /// element is considered missing or not and another to provide the /// replacement for the missing element. /// diff --git a/MoreLinq/FillForward.cs b/MoreLinq/FillForward.cs index 0577b8053..dd4b52aad 100644 --- a/MoreLinq/FillForward.cs +++ b/MoreLinq/FillForward.cs @@ -74,7 +74,7 @@ public static IEnumerable FillForward(this IEnumerable source, Func /// Returns a sequence with each missing element in the source replaced /// with one based on the previous non-missing element seen in that - /// sequence. Additional parameters specifiy two functions, one used to + /// sequence. Additional parameters specify two functions, one used to /// determine if an element is considered missing or not and another /// to provide the replacement for the missing element. /// diff --git a/MoreLinq/FullJoin.cs b/MoreLinq/FullJoin.cs index 251cd6ec5..877e35799 100644 --- a/MoreLinq/FullJoin.cs +++ b/MoreLinq/FullJoin.cs @@ -1,6 +1,6 @@ #region License and Terms // MoreLINQ - Extensions to LINQ to Objects -// Copysecond (c) 2017 Atif Aziz. All seconds reserved. +// Copyright (c) 2017 Atif Aziz. All seconds reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. diff --git a/MoreLinq/LeftJoin.cs b/MoreLinq/LeftJoin.cs index 6648dcefc..b20fe47a5 100644 --- a/MoreLinq/LeftJoin.cs +++ b/MoreLinq/LeftJoin.cs @@ -1,6 +1,6 @@ #region License and Terms // MoreLINQ - Extensions to LINQ to Objects -// Copysecond (c) 2017 Atif Aziz. All seconds reserved. +// Copyright (c) 2017 Atif Aziz. All seconds reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs index fd9698468..0236c5b06 100644 --- a/MoreLinq/Permutations.cs +++ b/MoreLinq/Permutations.cs @@ -51,7 +51,7 @@ sealed class PermutationEnumerator : IEnumerator> // However, there's a fly in the ointment. The factorial function grows VERY rapidly. // 13! overflows the range of a Int32; while 28! overflows the range of decimal. // To overcome these limitations, the algorithm relies on the fact that the factorial - // of N is equivalent to the evaluation of N-1 nested loops. Unfortunatley, you can't + // of N is equivalent to the evaluation of N-1 nested loops. Unfortunately, you can't // just code up a variable number of nested loops ... this is where .NET generators // with their elegant 'yield return' syntax come to the rescue. // @@ -95,9 +95,9 @@ public void Reset() // restore lexographic ordering of the permutation indexes for (var i = 0; i < _permutation.Length; i++) _permutation[i] = i; - // start a newiteration over the nested loop generator + // start a new iteration over the nested loop generator _generatorIterator = _generator.GetEnumerator(); - // we must advance the nestedloop iterator to the initial element, + // we must advance the nested loop iterator to the initial element, // this ensures that we only ever produce N!-1 calls to NextPermutation() _generatorIterator.MoveNext(); _hasMoreResults = true; // there's always at least one permutation: the original set itself @@ -123,7 +123,7 @@ public bool MoveNext() if (_hasMoreResults) _generatorIterator.Current(); // produce the next permutation ordering // we return prevResult rather than m_HasMoreResults because there is always - // at least one permtuation: the original set. Also, this provides a simple way + // at least one permutation: the original set. Also, this provides a simple way // to deal with the disparity between sets that have only one loop level (size 0-2) // and those that have two or more (size > 2). return prevResult; diff --git a/MoreLinq/Random.cs b/MoreLinq/Random.cs index 6d9b82700..684fddef8 100644 --- a/MoreLinq/Random.cs +++ b/MoreLinq/Random.cs @@ -148,7 +148,7 @@ public static IEnumerable Random(int minValue, int maxValue) /// /// Returns an infinite sequence of random integers between a given - /// minumum and a maximum using the supplied random number generator. + /// minimum and a maximum using the supplied random number generator. /// /// Generator used to produce random numbers /// Inclusive lower bound of the values returned diff --git a/MoreLinq/RandomSubset.cs b/MoreLinq/RandomSubset.cs index 6aafdc5a1..46a74aab5 100644 --- a/MoreLinq/RandomSubset.cs +++ b/MoreLinq/RandomSubset.cs @@ -66,7 +66,7 @@ public static IEnumerable RandomSubset(this IEnumerable source, int sub static IEnumerable RandomSubsetImpl(IEnumerable source, Random rand, Func, (T[], int)> seeder) { - // The simplest and most efficient way to return a random subet is to perform + // The simplest and most efficient way to return a random subset is to perform // an in-place, partial Fisher-Yates shuffle of the sequence. While we could do // a full shuffle, it would be wasteful in the cases where subsetSize is shorter // than the length of the sequence. @@ -93,7 +93,7 @@ static IEnumerable RandomSubsetImpl(IEnumerable source, Random rand, Fu --w; } - // yield the random subet as a new sequence + // yield the random subset as a new sequence for (var i = 0; i < subsetSize; i++) yield return array[i]; } diff --git a/MoreLinq/RightJoin.cs b/MoreLinq/RightJoin.cs index babbe28c1..7d19fbc39 100644 --- a/MoreLinq/RightJoin.cs +++ b/MoreLinq/RightJoin.cs @@ -1,6 +1,6 @@ #region License and Terms // MoreLINQ - Extensions to LINQ to Objects -// Copysecond (c) 2017 Atif Aziz. All seconds reserved. +// Copyright (c) 2017 Atif Aziz. All seconds reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. diff --git a/MoreLinq/ScanRight.cs b/MoreLinq/ScanRight.cs index d7c7b84a5..8afefcece 100644 --- a/MoreLinq/ScanRight.cs +++ b/MoreLinq/ScanRight.cs @@ -23,7 +23,7 @@ namespace MoreLinq static partial class MoreEnumerable { /// - /// Peforms a right-associative scan (inclusive prefix) on a sequence of elements. + /// Performs a right-associative scan (inclusive prefix) on a sequence of elements. /// This operator is the right-associative version of the /// LINQ operator. /// @@ -54,7 +54,7 @@ public static IEnumerable ScanRight(this IEnumerable } /// - /// Peforms a right-associative scan (inclusive prefix) on a sequence of elements. + /// Performs a right-associative scan (inclusive prefix) on a sequence of elements. /// The specified seed value is used as the initial accumulator value. /// This operator is the right-associative version of the /// LINQ operator. diff --git a/MoreLinq/Subsets.cs b/MoreLinq/Subsets.cs index 3ddf9f49a..1443f97f1 100644 --- a/MoreLinq/Subsets.cs +++ b/MoreLinq/Subsets.cs @@ -66,7 +66,7 @@ public static IEnumerable> Subsets(this IEnumerable sequence) yield return subset; } - yield return sequenceAsList; // the last subet is the original set itself + yield return sequenceAsList; // the last subset is the original set itself } } } @@ -95,9 +95,9 @@ public static IEnumerable> Subsets(this IEnumerable sequence, int if (subsetSize < 0) throw new ArgumentOutOfRangeException(nameof(subsetSize), "Subset size must be >= 0"); - // NOTE: Theres an interesting trade-off that we have to make in this operator. + // NOTE: There's an interesting trade-off that we have to make in this operator. // Ideally, we would throw an exception here if the {subsetSize} parameter is - // greater than the sequence length. Unforunately, determining the length of a + // greater than the sequence length. Unfortunately, determining the length of a // sequence is not always possible without enumerating it. Herein lies the rub. // We want Subsets() to be a deferred operation that only iterates the sequence // when the caller is ready to consume the results. However, this forces us to @@ -136,7 +136,7 @@ sealed class SubsetEnumerator : IEnumerator> int _m2; // current swap index (lower index) int _k; // size of the subset being produced int _n; // size of the original set (sequence) - int _z; // count of items excluded from the subet + int _z; // count of items excluded from the subset public SubsetEnumerator(IList set, int subsetSize) { diff --git a/MoreLinq/Window.cs b/MoreLinq/Window.cs index a3c5375f6..011793d1f 100644 --- a/MoreLinq/Window.cs +++ b/MoreLinq/Window.cs @@ -23,11 +23,11 @@ namespace MoreLinq public static partial class MoreEnumerable { /// - /// Processes a sequence into a series of subsequences representing a windowed subset of the original + /// Processes a sequence into a series of sub-sequences representing a windowed subset of the original /// /// /// The number of sequences returned is: Max(0, sequence.Count() - windowSize) + 1
- /// Returned subsequences are buffered, but the overall operation is streamed.
+ /// Returned sub-sequences are buffered, but the overall operation is streamed.
/// /// The type of the elements of the source sequence /// The sequence to evaluate a sliding window over @@ -70,11 +70,11 @@ public static IEnumerable> Window(this IEnumerable - /// Processes a sequence into a series of subsequences representing a windowed subset of the original + /// Processes a sequence into a series of sub-sequences representing a windowed subset of the original /// /// /// The number of sequences returned is: Max(0, sequence.Count() - windowSize) + 1
- /// Returned subsequences are buffered, but the overall operation is streamed.
+ /// Returned sub-sequences are buffered, but the overall operation is streamed.
/// /// The type of the elements of the source sequence /// The sequence to evaluate a sliding window over From 4c583f22128fad373a13568ac8803461f27c98ec Mon Sep 17 00:00:00 2001 From: Orace Date: Sat, 14 Jan 2023 18:18:41 +0100 Subject: [PATCH 022/157] Refactor "Interleave" to use linked list This is a squashed merge of PR #726. Co-authored-by: Atif Aziz --- MoreLinq/Interleave.cs | 53 +++++++++++++++++++++--------------------- 1 file changed, 27 insertions(+), 26 deletions(-) diff --git a/MoreLinq/Interleave.cs b/MoreLinq/Interleave.cs index a85c20977..47ec2af7e 100644 --- a/MoreLinq/Interleave.cs +++ b/MoreLinq/Interleave.cs @@ -50,54 +50,55 @@ public static IEnumerable Interleave(this IEnumerable sequence, params if (otherSequences.Any(s => s == null)) throw new ArgumentNullException(nameof(otherSequences), "One or more sequences passed to Interleave was null."); - return _(); IEnumerable _() + return _(otherSequences.Prepend(sequence)); + + static IEnumerable _(IEnumerable> sequences) { - var sequences = new[] { sequence }.Concat(otherSequences); - var enumerators = new List?>(); + var enumerators = new LinkedList>(); try { - foreach (var enumerator in sequences.Select(s => s.GetEnumerator())) + // First, yield first element of each sequence. + + foreach (var sequence in sequences) { - enumerators.Add(enumerator); + var enumerator = sequence.GetEnumerator(); + + enumerators.AddLast(enumerator); if (enumerator.MoveNext()) { yield return enumerator.Current; } - else + else // Dispose and remove empty sequence { - enumerators.Remove(enumerator); enumerator.Dispose(); + enumerators.Remove(enumerator); } } - var hasNext = true; - while (hasNext) + // Then, yield remaining elements from each sequence. + + var node = enumerators.First; + while (node is { Value: var enumerator, Next: var nextNode }) { - hasNext = false; - for (var i = 0; i < enumerators.Count; i++) + if (enumerator.MoveNext()) { - var enumerator = enumerators[i]; - if (enumerator == null) - continue; - - if (enumerator.MoveNext()) - { - hasNext = true; - yield return enumerator.Current; - } - else - { - enumerators[i] = null; - enumerator.Dispose(); - } + yield return enumerator.Current; } + else + { + enumerator.Dispose(); + enumerators.Remove(node); + } + + // Work on next node or restart from first one. + node = nextNode ?? enumerators.First; } } finally { foreach (var enumerator in enumerators) - enumerator?.Dispose(); + enumerator.Dispose(); } } } From c617dea813ffce806a133df0eeec3399c11990da Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 14 Jan 2023 20:04:58 +0100 Subject: [PATCH 023/157] Update packages to latest versions (#920) --- MoreLinq.Test/MoreLinq.Test.csproj | 9 ++++++--- MoreLinq/MoreLinq.csproj | 2 +- .../MoreLinq.ExtensionsGenerator.csproj | 2 +- 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index ac5c2885c..fe1ab869c 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -39,11 +39,14 @@ runtime; build; native; contentfiles; analyzers; buildtransitive - + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + - - + + diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index dccb0afc0..2dc1c2a92 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -152,7 +152,7 @@ all - + diff --git a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj index e1c9c8e49..faf971cfd 100644 --- a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj +++ b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj @@ -5,7 +5,7 @@ false - + From 34c7ebe8d7c8d1edab80077a8413a26e661b2341 Mon Sep 17 00:00:00 2001 From: Orace Date: Sun, 15 Jan 2023 00:18:27 +0100 Subject: [PATCH 024/157] Add more "Interleave" tests (#728) Co-authored-by: Atif Aziz --- MoreLinq.Test/InterleaveTest.cs | 53 +++++++++++++++++++++++++++++++-- 1 file changed, 50 insertions(+), 3 deletions(-) diff --git a/MoreLinq.Test/InterleaveTest.cs b/MoreLinq.Test/InterleaveTest.cs index 8eecc16a3..a8bfe4b56 100644 --- a/MoreLinq.Test/InterleaveTest.cs +++ b/MoreLinq.Test/InterleaveTest.cs @@ -17,6 +17,7 @@ namespace MoreLinq.Test { + using System.Collections.Generic; using NUnit.Framework; /// @@ -49,6 +50,20 @@ public void TestInterleaveDisposesOnErrorAtGetEnumerator() Throws.BreakException); } + /// + /// Verify that Interleave early throw ArgumentNullException when an element + /// of otherSequences is null. + /// + [Test] + public void TestInterleaveEarlyThrowOnNullElementInOtherSequences() + { + var sequenceA = Enumerable.Range(1, 1); + var otherSequences = new IEnumerable[] { null! }; + + Assert.That(() => sequenceA.Interleave(otherSequences), + Throws.ArgumentNullException("otherSequences")); + } + /// /// Verify that interleaving disposes those enumerators that it managed /// to open successfully @@ -82,10 +97,42 @@ public void TestInterleaveDoNotCallGetEnumeratorEagerly() [Test] public void TestInterleaveDoNoCallMoveNextEagerly() { - var sequenceA = Enumerable.Range(1, 1); - var sequenceB = MoreEnumerable.From(() => throw new TestException()); + using var sequenceA = TestingSequence.Of(1); + using var sequenceB = MoreEnumerable.From(() => throw new TestException()) + .AsTestingSequence(); + var result = sequenceA.Interleave(sequenceB).Take(1); - sequenceA.Interleave(sequenceB).Take(1).Consume(); + Assert.That(() => result.Consume(), Throws.Nothing); + } + + /// + /// Verify that interleaving disposes those enumerators that it managed + /// to open successfully + /// + [Test] + public void TestInterleaveDisposesOnError() + { + using var sequenceA = TestingSequence.Of(); + + Assert.That(() => sequenceA.Interleave(new BreakingSequence()).Consume(), + Throws.BreakException); // Expected and thrown by BreakingSequence + } + + /// + /// Verify that, in case of partial enumeration, interleaving disposes those + /// enumerators that it managed to open successfully + /// + [TestCase(0)] + [TestCase(1)] + [TestCase(2)] + [TestCase(3)] + public void TestInterleaveDisposesOnPartialEnumeration(int count) + { + using var sequenceA = TestingSequence.Of(1); + using var sequenceB = TestingSequence.Of(2); + using var sequenceC = TestingSequence.Of(3); + + sequenceA.Interleave(sequenceB, sequenceC).Take(count).Consume(); } /// From 78b869973fc9f4da9ce9afeac2c5ada0ce6b129d Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 15 Jan 2023 10:39:07 +0100 Subject: [PATCH 025/157] Retire our delegating "Comparer" (#921) --- MoreLinq.Test/Comparer.cs | 45 ------------------------------ MoreLinq.Test/MoreLinq.Test.csproj | 1 - MoreLinq.Test/OrderByTest.cs | 9 +----- MoreLinq.Test/RankTest.cs | 5 ++-- 4 files changed, 4 insertions(+), 56 deletions(-) delete mode 100644 MoreLinq.Test/Comparer.cs diff --git a/MoreLinq.Test/Comparer.cs b/MoreLinq.Test/Comparer.cs deleted file mode 100644 index 7f9f26c29..000000000 --- a/MoreLinq.Test/Comparer.cs +++ /dev/null @@ -1,45 +0,0 @@ -#region License and Terms -// MoreLINQ - Extensions to LINQ to Objects -// Copyright (c) 2017 Atif Aziz. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -#endregion - -namespace MoreLinq.Test -{ - using System; - using System.Collections.Generic; - - sealed class Comparer - { - /// - /// Creates an given a - /// . - /// - - public static IComparer Create(Func compare) => - new DelegatingComparer(compare); - - sealed class DelegatingComparer : IComparer - { - readonly Func _comparer; - - public DelegatingComparer(Func comparer) - { - _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer)); - } - - public int Compare(T? x, T? y) => _comparer(x, y); - } - } -} diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index fe1ab869c..8c2a32e67 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -72,7 +72,6 @@ - diff --git a/MoreLinq.Test/OrderByTest.cs b/MoreLinq.Test/OrderByTest.cs index cb6f8bf1d..f8f06a2ce 100644 --- a/MoreLinq.Test/OrderByTest.cs +++ b/MoreLinq.Test/OrderByTest.cs @@ -47,14 +47,7 @@ public void TestOrderBySelectorPreserved() } static readonly IComparer NumericStringComparer = - Comparer.Create((string? a, string? b) => - (a, b) switch - { - (null, null) => 0, - (null, _) => -1, - (_, null) => 1, - var (sa, sb) => int.Parse(sa).CompareTo(int.Parse(sb)) - }); + Comparer.Create((a, b) => int.Parse(a).CompareTo(int.Parse(b))); /// /// Verify that OrderBy preserves the comparer diff --git a/MoreLinq.Test/RankTest.cs b/MoreLinq.Test/RankTest.cs index 6965c1226..381b8fd35 100644 --- a/MoreLinq.Test/RankTest.cs +++ b/MoreLinq.Test/RankTest.cs @@ -18,6 +18,7 @@ namespace MoreLinq.Test { using System; + using System.Collections.Generic; using NUnit.Framework; /// @@ -172,8 +173,8 @@ public void TestRankCustomComparer() var ordinals = Enumerable.Range(1, count); var sequence = ordinals.Select( x => new DateTime(2010,x,20-x) ); // invert the CompareTo operation to Rank in reverse order (ascending to descending) - var resultA = sequence.AsTestingSequence().Rank(Comparer.Create((a, b) => -a.CompareTo(b))); - var resultB = sequence.AsTestingSequence().RankBy(x => x.Day, Comparer.Create((a, b) => -a.CompareTo(b))); + var resultA = sequence.AsTestingSequence().Rank(Comparer.Create((a, b) => -a.CompareTo(b))); + var resultB = sequence.AsTestingSequence().RankBy(x => x.Day, Comparer.Create((a, b) => -a.CompareTo(b))); Assert.That(resultA, Is.EqualTo(ordinals)); Assert.That(resultB, Is.EqualTo(ordinals.Reverse())); From 63d4efe4f3283661b4866c61bb6bd2664a5c63bd Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 15 Jan 2023 13:13:09 +0100 Subject: [PATCH 026/157] Mark local function static where possible --- MoreLinq.Test/MemoizeTest.cs | 2 +- MoreLinq.Test/TraceTest.cs | 2 +- MoreLinq/ToDataTable.cs | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/MoreLinq.Test/MemoizeTest.cs b/MoreLinq.Test/MemoizeTest.cs index d600afc68..d6e12f5d1 100644 --- a/MoreLinq.Test/MemoizeTest.cs +++ b/MoreLinq.Test/MemoizeTest.cs @@ -43,7 +43,7 @@ public void MemoizeReturningExpectedElementsWhenUsedAtInnerForEach() flowArray.AssertSequenceEqual(flowBuffer); - IEnumerable InnerForEach(IEnumerable source) + static IEnumerable InnerForEach(IEnumerable source) { var firstVisitAtInnerLoopDone = false; diff --git a/MoreLinq.Test/TraceTest.cs b/MoreLinq.Test/TraceTest.cs index 65dc4f2b3..5c9725a35 100644 --- a/MoreLinq.Test/TraceTest.cs +++ b/MoreLinq.Test/TraceTest.cs @@ -82,7 +82,7 @@ static IEnumerable Lines(string str) while (e.MoveNext()) yield return e.Current; - IEnumerator _(TextReader reader) + static IEnumerator _(TextReader reader) { while (reader.ReadLine() is { } line) yield return line; diff --git a/MoreLinq/ToDataTable.cs b/MoreLinq/ToDataTable.cs index 793eb6bc5..2342ae0f1 100644 --- a/MoreLinq/ToDataTable.cs +++ b/MoreLinq/ToDataTable.cs @@ -159,7 +159,7 @@ static IEnumerable PrepareMemberInfos(ICollection Date: Sun, 15 Jan 2023 13:44:23 +0100 Subject: [PATCH 027/157] Address to-do: consolidate testing sequence implementations --- MoreLinq.Test/MemoizeTest.cs | 67 +++----------------------------- MoreLinq.Test/TestingSequence.cs | 28 ++++++++++--- 2 files changed, 29 insertions(+), 66 deletions(-) diff --git a/MoreLinq.Test/MemoizeTest.cs b/MoreLinq.Test/MemoizeTest.cs index d6e12f5d1..d498e5222 100644 --- a/MoreLinq.Test/MemoizeTest.cs +++ b/MoreLinq.Test/MemoizeTest.cs @@ -22,7 +22,6 @@ namespace MoreLinq.Test { using System; - using System.Collections; using System.Collections.Generic; using System.Threading; using Delegate = Delegating.Delegate; @@ -245,13 +244,8 @@ public void MemoizeRethrowsErrorDuringIterationToAllIteratorsUntilDisposed() { var error = new Exception("This is a test exception."); - IEnumerable TestSequence() - { - yield return 123; - throw error; - } - - var xs = new DisposalTrackingSequence(TestSequence()); + var xs = MoreEnumerable.From(() => 123, () => throw error) + .AsTestingSequence(TestingSequence.Options.AllowMultipleEnumerations); var memoized = xs.Memoize(); using ((IDisposable) memoized) using (var r1 = memoized.Read()) @@ -274,14 +268,10 @@ public void MemoizeRethrowsErrorDuringIterationStartToAllIteratorsUntilDisposed( var error = new Exception("This is a test exception."); var i = 0; - IEnumerable TestSequence() - { - if (0 == i++) // throw at start for first iteration only - throw error; - yield return 42; - } - - var xs = new DisposalTrackingSequence(TestSequence()); + var xs = MoreEnumerable.From(() => 0 == i++ + ? throw error // throw at start for first iteration only + : 42) + .AsTestingSequence(TestingSequence.Options.AllowMultipleEnumerations); var memoized = xs.Memoize(); using ((IDisposable) memoized) using (var r1 = memoized.Read()) @@ -315,50 +305,5 @@ public void MemoizeRethrowsErrorDuringFirstIterationStartToAllIterationsUntilDis ((IDisposable) memo).Dispose(); Assert.That(memo.Single(), Is.EqualTo(obj)); } - - // TODO Consolidate with MoreLinq.Test.TestingSequence? - - sealed class DisposalTrackingSequence : IEnumerable, IDisposable - { - readonly IEnumerable _sequence; - - internal DisposalTrackingSequence(IEnumerable sequence) => - _sequence = sequence; - - public bool? IsDisposed { get; private set; } - - void IDisposable.Dispose() => IsDisposed = null; - - public IEnumerator GetEnumerator() - { - var enumerator = new DisposeTestingSequenceEnumerator(_sequence.GetEnumerator()); - IsDisposed = false; - enumerator.Disposed += delegate { IsDisposed = true; }; - return enumerator; - } - - IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); - - sealed class DisposeTestingSequenceEnumerator : IEnumerator - { - readonly IEnumerator _sequence; - - public event EventHandler? Disposed; - - public DisposeTestingSequenceEnumerator(IEnumerator sequence) => - _sequence = sequence; - - public T Current => _sequence.Current; - object? IEnumerator.Current => Current; - public void Reset() => _sequence.Reset(); - public bool MoveNext() => _sequence.MoveNext(); - - public void Dispose() - { - _sequence.Dispose(); - Disposed?.Invoke(this, EventArgs.Empty); - } - } - } } } diff --git a/MoreLinq.Test/TestingSequence.cs b/MoreLinq.Test/TestingSequence.cs index 0a90139d2..98572d7cc 100644 --- a/MoreLinq.Test/TestingSequence.cs +++ b/MoreLinq.Test/TestingSequence.cs @@ -25,12 +25,23 @@ namespace MoreLinq.Test static class TestingSequence { internal static TestingSequence Of(params T[] elements) => - new TestingSequence(elements); + Of(Options.None, elements); - internal static TestingSequence AsTestingSequence(this IEnumerable source) => + internal static TestingSequence Of(Options options, params T[] elements) => + elements.AsTestingSequence(options); + + internal static TestingSequence AsTestingSequence(this IEnumerable source, + Options options = Options.None) => source != null - ? new TestingSequence(source) + ? new TestingSequence(source) { IsReiterationAllowed = options.HasFlag(Options.AllowMultipleEnumerations) } : throw new ArgumentNullException(nameof(source)); + + [Flags] + public enum Options + { + None, + AllowMultipleEnumerations + } } /// @@ -46,6 +57,8 @@ sealed class TestingSequence : IEnumerable, IDisposable internal TestingSequence(IEnumerable sequence) => _sequence = sequence; + public bool IsDisposed => _disposed ?? false; + public bool IsReiterationAllowed { get; init; } public int MoveNextCallCount { get; private set; } void IDisposable.Dispose() => @@ -64,7 +77,9 @@ void AssertDisposed() public IEnumerator GetEnumerator() { - Assert.That(_sequence, Is.Not.Null, "LINQ operators should not enumerate a sequence more than once."); + if (!IsReiterationAllowed) + Assert.That(_sequence, Is.Not.Null, "LINQ operators should not enumerate a sequence more than once."); + Debug.Assert(_sequence is not null); var enumerator = _sequence.GetEnumerator().AsWatchable(); @@ -81,7 +96,10 @@ public IEnumerator GetEnumerator() ended = !moved; MoveNextCallCount++; }; - _sequence = null; + + if (!IsReiterationAllowed) + _sequence = null; + return enumerator; } From 583c51bba768334f4883b1d70b40fb8e9b6633ca Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 15 Jan 2023 15:30:28 +0100 Subject: [PATCH 028/157] Use tuples to perform swap in "Permutations" --- MoreLinq/Permutations.cs | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs index 0236c5b06..e69fba7ea 100644 --- a/MoreLinq/Permutations.cs +++ b/MoreLinq/Permutations.cs @@ -147,10 +147,7 @@ void NextPermutation() while (_permutation[j] > _permutation[k]) k--; - // interchange m_Permutation[j] and m_Permutation[k] - var oldValue = _permutation[k]; - _permutation[k] = _permutation[j]; - _permutation[j] = oldValue; + (_permutation[j], _permutation[k]) = (_permutation[k], _permutation[j]); // move the tail of the permutation after the jth position in increasing order var x = _permutation.Length - 1; @@ -158,9 +155,7 @@ void NextPermutation() while (x > y) { - oldValue = _permutation[y]; - _permutation[y] = _permutation[x]; - _permutation[x] = oldValue; + (_permutation[x], _permutation[y]) = (_permutation[y], _permutation[x]); x--; y++; } From fb29c31a1e4ed3ca909f99c7f66c187384488434 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 15 Jan 2023 20:39:24 +0100 Subject: [PATCH 029/157] Fix exception thrown by current buffer index implementation --- MoreLinq.Test/BatchTest.cs | 14 ++++++++++++++ MoreLinq/Experimental/Batch.cs | 3 +-- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/MoreLinq.Test/BatchTest.cs b/MoreLinq.Test/BatchTest.cs index 3b50d7426..c6b875f83 100644 --- a/MoreLinq.Test/BatchTest.cs +++ b/MoreLinq.Test/BatchTest.cs @@ -307,6 +307,20 @@ public void BatchUpdatesCurrentListInPlace() Assert.That(current, Is.Empty); } + [Test] + public void BatchCurrentListIndexerWithBadIndexThrowsArgumentOutOfRangeException() + { + using var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9); + using var pool = new TestArrayPool(); + + var result = input.Batch(4, pool, current => current, current => (ICurrentBuffer)current); + + using var reader = result.Read(); + var current = reader.Read(); + + Assert.That(() => current[100], Throws.ArgumentOutOfRangeException("index")); + } + [Test] public void BatchCallsBucketSelectorBeforeIteratingSource() { diff --git a/MoreLinq/Experimental/Batch.cs b/MoreLinq/Experimental/Batch.cs index ae40954ff..49bb1f3f4 100644 --- a/MoreLinq/Experimental/Batch.cs +++ b/MoreLinq/Experimental/Batch.cs @@ -268,9 +268,8 @@ public bool UpdateWithNext() public override T this[int index] { - get => index >= 0 && index < Count ? _array[index] : throw new IndexOutOfRangeException(); + get => index >= 0 && index < Count ? _array[index] : throw new ArgumentOutOfRangeException(nameof(index)); set => throw new NotSupportedException(); - } public void Dispose() From 15f35f00d303187a19cf736c00973b04a6efa028 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 15 Jan 2023 15:38:29 +0100 Subject: [PATCH 030/157] Rewrite next permutation while-loop into a for-loop --- MoreLinq/Permutations.cs | 9 +-------- 1 file changed, 1 insertion(+), 8 deletions(-) diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs index e69fba7ea..a51359dc2 100644 --- a/MoreLinq/Permutations.cs +++ b/MoreLinq/Permutations.cs @@ -150,15 +150,8 @@ void NextPermutation() (_permutation[j], _permutation[k]) = (_permutation[k], _permutation[j]); // move the tail of the permutation after the jth position in increasing order - var x = _permutation.Length - 1; - var y = j + 1; - - while (x > y) - { + for (int x = _permutation.Length - 1, y = j + 1; x > y; x--, y++) (_permutation[x], _permutation[y]) = (_permutation[y], _permutation[x]); - x--; - y++; - } } /// From 4315fdae045b456e08f9dcbcaf56f06389986378 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 16 Jan 2023 20:05:04 +0100 Subject: [PATCH 031/157] Consolidate error formatting between "AssertCount" & "Fold" --- MoreLinq.Test/AssertCountTest.cs | 14 +++++++++----- MoreLinq.Test/FoldTest.cs | 9 ++++++--- MoreLinq/AssertCount.cs | 12 +++++------- MoreLinq/Fold.cs | 9 ++------- 4 files changed, 22 insertions(+), 22 deletions(-) diff --git a/MoreLinq.Test/AssertCountTest.cs b/MoreLinq.Test/AssertCountTest.cs index b2b165564..2a6e5ddf3 100644 --- a/MoreLinq.Test/AssertCountTest.cs +++ b/MoreLinq.Test/AssertCountTest.cs @@ -53,13 +53,17 @@ public void AssertCountLongSequence() Throws.TypeOf()); } - [TestCase(4, "Sequence contains too few elements when exactly 4 were expected.")] - [TestCase(2, "Sequence contains too many elements when exactly 2 were expected.")] - public void AssertCountDefaultExceptionMessageVariesWithCase(int count, string expectedMessage) + [TestCase("", 1, "Sequence contains too few elements when exactly 1 was expected.")] + [TestCase("foo,bar,baz", 1, "Sequence contains too many elements when exactly 1 was expected.")] + [TestCase("foo,bar,baz", 4, "Sequence contains too few elements when exactly 4 were expected.")] + [TestCase("foo,bar,baz", 2, "Sequence contains too many elements when exactly 2 were expected.")] + public void AssertCountDefaultExceptionMessageVariesWithCase(string str, int count, string expectedMessage) { - var tokens = "foo,bar,baz".GenerateSplits(','); + var tokens = str.GenerateSplits(',') + .Where(t => t.Length > 0) + .AssertCount(count); - Assert.That(() => tokens.AssertCount(count).Consume(), + Assert.That(() => tokens.Consume(), Throws.TypeOf().With.Message.EqualTo(expectedMessage)); } diff --git a/MoreLinq.Test/FoldTest.cs b/MoreLinq.Test/FoldTest.cs index 25b2d8101..b6c2972f6 100644 --- a/MoreLinq.Test/FoldTest.cs +++ b/MoreLinq.Test/FoldTest.cs @@ -27,21 +27,24 @@ public class FoldTest public void FoldWithTooFewItems() { Assert.That(() => Enumerable.Range(1, 3).Fold(BreakingFunc.Of()), - Throws.TypeOf()); + Throws.TypeOf() + .And.Message.EqualTo("Sequence contains too few elements when exactly 4 were expected.")); } [Test] public void FoldWithEmptySequence() { Assert.That(() => Enumerable.Empty().Fold(BreakingFunc.Of()), - Throws.TypeOf()); + Throws.TypeOf() + .And.Message.EqualTo("Sequence contains too few elements when exactly 1 was expected.")); } [Test] public void FoldWithTooManyItems() { Assert.That(() => Enumerable.Range(1, 3).Fold(BreakingFunc.Of()), - Throws.TypeOf()); + Throws.TypeOf() + .And.Message.EqualTo("Sequence contains too many elements when exactly 2 were expected.")); } [Test] diff --git a/MoreLinq/AssertCount.cs b/MoreLinq/AssertCount.cs index db4ff8e4f..f9467c7c1 100644 --- a/MoreLinq/AssertCount.cs +++ b/MoreLinq/AssertCount.cs @@ -71,13 +71,11 @@ public static IEnumerable AssertCount(this IEnumerable errorSelector) => AssertCountImpl(source, count, errorSelector); - static Exception OnAssertCountFailure(int cmp, int count) - { - var message = cmp < 0 - ? "Sequence contains too few elements when exactly {0} were expected." - : "Sequence contains too many elements when exactly {0} were expected."; - return new SequenceException(string.Format(message, count.ToString("N0"))); - } + static Exception OnAssertCountFailure(int cmp, int count) => + new SequenceException(FormatSequenceLengthErrorMessage(cmp, count)); + + internal static string FormatSequenceLengthErrorMessage(int cmp, int count) => + $"Sequence contains too {(cmp < 0 ? "few" : "many")} elements when exactly {count:N0} {(count == 1 ? "was" : "were")} expected."; #endif diff --git a/MoreLinq/Fold.cs b/MoreLinq/Fold.cs index 31fa1bbef..4b77b4856 100644 --- a/MoreLinq/Fold.cs +++ b/MoreLinq/Fold.cs @@ -91,12 +91,7 @@ static TResult FoldImpl(IEnumerable source, int count, static readonly Func OnFolderSourceSizeErrorSelector = OnFolderSourceSizeError; - static Exception OnFolderSourceSizeError(int cmp, int count) - { - var message = cmp < 0 - ? "Sequence contains too few elements when exactly {0} {1} expected." - : "Sequence contains too many elements when exactly {0} {1} expected."; - return new InvalidOperationException(string.Format(message, count.ToString("N0"), count == 1 ? "was" : "were")); - } + static Exception OnFolderSourceSizeError(int cmp, int count) => + new InvalidOperationException(FormatSequenceLengthErrorMessage(cmp, count)); } } From f4806f5030eba2b4cb10409f40613f8c2d0dc7d7 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 16 Jan 2023 23:43:17 +0100 Subject: [PATCH 032/157] Enable default compile items in test project This is a squashed merge or PR #930. --- MoreLinq.Test/MoreLinq.Test.csproj | 29 ++++------------------------- 1 file changed, 4 insertions(+), 25 deletions(-) diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index 8c2a32e67..f2eff7fd3 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -8,7 +8,6 @@ Exe true false - false library MoreLinq.Test.Program @@ -51,38 +50,18 @@ - + + + + - - - - - - - - - - - - - - - - - - - - - - - From 18dcf2ca5a92303460848dd00ef7a590cbd74349 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 17 Jan 2023 12:07:56 +0100 Subject: [PATCH 033/157] Enable static analysis; addressing issues --- Directory.Build.props | 2 + MoreLinq.Test/.editorconfig | 28 ++++++++++++++ MoreLinq.Test/AcquireTest.cs | 2 +- MoreLinq.Test/AggregateRightTest.cs | 2 +- MoreLinq.Test/AggregateTest.cs | 2 +- MoreLinq.Test/AssertTest.cs | 2 +- MoreLinq.Test/BatchTest.cs | 8 ++-- MoreLinq.Test/ChooseTest.cs | 2 + MoreLinq.Test/EvaluateTest.cs | 2 +- MoreLinq.Test/Extensions.cs | 46 +++++++++++++++++++++++ MoreLinq.Test/FillForwardTest.cs | 3 +- MoreLinq.Test/FlattenTest.cs | 6 +-- MoreLinq.Test/FromTest.cs | 2 +- MoreLinq.Test/GenerateTest.cs | 2 +- MoreLinq.Test/InterleaveTest.cs | 2 +- MoreLinq.Test/MemoizeTest.cs | 40 +++++++++++--------- MoreLinq.Test/NullArgumentTest.cs | 21 +++++++---- MoreLinq.Test/OrderByTest.cs | 5 ++- MoreLinq.Test/OrderedMergeTest.cs | 2 +- MoreLinq.Test/PipeTest.cs | 2 +- MoreLinq.Test/Program.cs | 8 ++-- MoreLinq.Test/RankTest.cs | 34 ++++++++++------- MoreLinq.Test/ReturnTest.cs | 2 +- MoreLinq.Test/ScanRightTest.cs | 2 +- MoreLinq.Test/SegmentTest.cs | 3 +- MoreLinq.Test/SkipUntilTest.cs | 3 +- MoreLinq.Test/TestException.cs | 6 ++- MoreLinq.Test/ToDataTableTest.cs | 10 +++-- MoreLinq.Test/TraverseTest.cs | 2 +- MoreLinq.Test/TrySingleTest.cs | 6 ++- MoreLinq.Test/ZipLongestTest.cs | 2 +- MoreLinq/EmptyArray.cs | 9 ++++- MoreLinq/Experimental/Await.cs | 51 ++++++++++++++++--------- MoreLinq/Extensions.g.cs | 1 + MoreLinq/Fold.cs | 2 + MoreLinq/From.cs | 6 +++ MoreLinq/GlobalRandom.cs | 17 ++++++--- MoreLinq/MaxBy.cs | 2 + MoreLinq/PendNode.cs | 2 +- MoreLinq/Permutations.cs | 2 +- MoreLinq/Random.cs | 2 + MoreLinq/RandomSubset.cs | 2 + MoreLinq/Repeat.cs | 4 ++ MoreLinq/Return.cs | 2 +- MoreLinq/ToArrayByIndex.cs | 24 +++++++++--- MoreLinq/Trace.cs | 2 +- MoreLinq/UnreachableException.cs | 58 +++++++++++++++++++++++++++++ bld/ExtensionsGenerator/Program.cs | 12 +++++- 48 files changed, 347 insertions(+), 110 deletions(-) create mode 100644 MoreLinq.Test/.editorconfig create mode 100644 MoreLinq.Test/Extensions.cs create mode 100644 MoreLinq/UnreachableException.cs diff --git a/Directory.Build.props b/Directory.Build.props index 11286bf3d..0b85fe477 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -3,5 +3,7 @@ 11 enable true + 7.0-all + true diff --git a/MoreLinq.Test/.editorconfig b/MoreLinq.Test/.editorconfig new file mode 100644 index 000000000..cc328a0d1 --- /dev/null +++ b/MoreLinq.Test/.editorconfig @@ -0,0 +1,28 @@ +[*.cs] + +# CA1034: Nested types should not be visible +dotnet_diagnostic.CA1034.severity = none + +# CA1062: Validate arguments of public methods +dotnet_diagnostic.CA1062.severity = none + +# CA1825: Avoid zero-length array allocations +dotnet_diagnostic.CA1825.severity = suggestion + +# CA1032: Implement standard exception constructors +dotnet_diagnostic.CA1032.severity = none + +# CA1064: Exceptions should be public +dotnet_diagnostic.CA1064.severity = none + +# CA1303: Do not pass literals as localized parameters +dotnet_diagnostic.CA1303.severity = none + +# CA5394: Do not use insecure randomness +dotnet_diagnostic.CA5394.severity = none + +# CA1707: Identifiers should not contain underscores +dotnet_diagnostic.CA1707.severity = none + +# CA1308: Normalize strings to uppercase +dotnet_diagnostic.CA1308.severity = none diff --git a/MoreLinq.Test/AcquireTest.cs b/MoreLinq.Test/AcquireTest.cs index 14025320b..18050ed78 100644 --- a/MoreLinq.Test/AcquireTest.cs +++ b/MoreLinq.Test/AcquireTest.cs @@ -66,7 +66,7 @@ public void AcquireSome() Assert.That(c, Is.Null); } - class Disposable : IDisposable + sealed class Disposable : IDisposable { public bool Disposed { get; private set; } public void Dispose() { Disposed = true; } diff --git a/MoreLinq.Test/AggregateRightTest.cs b/MoreLinq.Test/AggregateRightTest.cs index 434d16c93..7ecd4825e 100644 --- a/MoreLinq.Test/AggregateRightTest.cs +++ b/MoreLinq.Test/AggregateRightTest.cs @@ -46,7 +46,7 @@ public void AggregateRightFuncIsNotInvokedOnSingleElementSequence() [TestCase(SourceKind.Sequence)] public void AggregateRight(SourceKind sourceKind) { - var enumerable = Enumerable.Range(1, 5).Select(x => x.ToString()).ToSourceKind(sourceKind); + var enumerable = Enumerable.Range(1, 5).Select(x => x.ToInvariantString()).ToSourceKind(sourceKind); var result = enumerable.AggregateRight((a, b) => $"({a}+{b})"); diff --git a/MoreLinq.Test/AggregateTest.cs b/MoreLinq.Test/AggregateTest.cs index 690207c5b..d9cf0e6fb 100644 --- a/MoreLinq.Test/AggregateTest.cs +++ b/MoreLinq.Test/AggregateTest.cs @@ -69,7 +69,7 @@ into m ? invoke.GetParameters() .Select(p => Expression.Parameter(p.ParameterType)) .ToArray() - : throw new Exception("""Method "Invoke" not found."""), + : throw new MissingMethodException("""Method "Invoke" not found."""), } into m let resultSelector = diff --git a/MoreLinq.Test/AssertTest.cs b/MoreLinq.Test/AssertTest.cs index e5bd40d9e..553701ff2 100644 --- a/MoreLinq.Test/AssertTest.cs +++ b/MoreLinq.Test/AssertTest.cs @@ -63,7 +63,7 @@ public void AssertSequenceWithInvalidElementsAndCustomError() .With.Property(nameof(ValueException.Value)).EqualTo(7)); } - class ValueException : Exception + sealed class ValueException : Exception { public object Value { get; } public ValueException(object value) { Value = value; } diff --git a/MoreLinq.Test/BatchTest.cs b/MoreLinq.Test/BatchTest.cs index c6b875f83..e2b46ac65 100644 --- a/MoreLinq.Test/BatchTest.cs +++ b/MoreLinq.Test/BatchTest.cs @@ -251,7 +251,7 @@ public void BatchEmptySource(SourceKind kind) public void BatchFilterBucket() { const int scale = 2; - var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9); + using var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9); using var pool = new TestArrayPool(); var result = input.Batch(3, pool, @@ -270,7 +270,7 @@ public void BatchFilterBucket() [Test] public void BatchSumBucket() { - var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9); + using var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9); using var pool = new TestArrayPool(); var result = input.Batch(3, pool, Enumerable.Sum); @@ -289,7 +289,7 @@ public void BatchSumBucket() [Test] public void BatchUpdatesCurrentListInPlace() { - var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9); + using var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9); using var pool = new TestArrayPool(); var result = input.Batch(4, pool, current => current, current => (ICurrentBuffer)current); @@ -351,7 +351,7 @@ IEnumerable Source() [Test] public void BatchBucketSelectorCurrentList() { - var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9); + using var input = TestingSequence.Of(1, 2, 3, 4, 5, 6, 7, 8, 9); using var pool = new TestArrayPool(); int[]? bucketSelectorItems = null; diff --git a/MoreLinq.Test/ChooseTest.cs b/MoreLinq.Test/ChooseTest.cs index 3f6baf592..138b565c4 100644 --- a/MoreLinq.Test/ChooseTest.cs +++ b/MoreLinq.Test/ChooseTest.cs @@ -67,7 +67,9 @@ static class Option static class Option { +#pragma warning disable CA1805 // Do not initialize unnecessarily (avoids CS0649) public static readonly (bool IsSome, T Value) None = default; +#pragma warning restore CA1805 // Do not initialize unnecessarily } [Test] diff --git a/MoreLinq.Test/EvaluateTest.cs b/MoreLinq.Test/EvaluateTest.cs index 7330fce27..40bd4eaab 100644 --- a/MoreLinq.Test/EvaluateTest.cs +++ b/MoreLinq.Test/EvaluateTest.cs @@ -20,7 +20,7 @@ namespace MoreLinq.Test using System; using NUnit.Framework; - class EvaluateTest + public class EvaluateTest { [Test] public void TestEvaluateIsLazy() diff --git a/MoreLinq.Test/Extensions.cs b/MoreLinq.Test/Extensions.cs new file mode 100644 index 000000000..5ee4520de --- /dev/null +++ b/MoreLinq.Test/Extensions.cs @@ -0,0 +1,46 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2009 Atif Aziz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq.Test +{ + using System; + using System.Diagnostics; + using System.Globalization; + + static class Extensions + { + /// + /// Formats the value of this object using the invariant culture. + /// + + [DebuggerStepThrough] + public static string ToInvariantString(this T formattable) where T : IFormattable => + formattable.ToInvariantString(null); + + /// + /// Formats the value of this object using a specific format and the + /// invariant culture. + /// + + [DebuggerStepThrough] + public static string ToInvariantString(this T formattable, string? format) where T : IFormattable + { + if (formattable is null) throw new ArgumentNullException(nameof(formattable)); + return formattable.ToString(format, CultureInfo.InvariantCulture); + } + } +} diff --git a/MoreLinq.Test/FillForwardTest.cs b/MoreLinq.Test/FillForwardTest.cs index 8eb004942..c881210e9 100644 --- a/MoreLinq.Test/FillForwardTest.cs +++ b/MoreLinq.Test/FillForwardTest.cs @@ -17,6 +17,7 @@ namespace MoreLinq.Test { + using System.Globalization; using System.Text.RegularExpressions; using NUnit.Framework; @@ -62,7 +63,7 @@ select line.Trim() into line Continent = cont, Country = ctry, City = city, - Value = int.Parse(val), + Value = int.Parse(val, CultureInfo.InvariantCulture), }); data = data.FillForward(e => e.Continent == "-", (e, f) => new { f.Continent, e.Country, e.City, e.Value }) diff --git a/MoreLinq.Test/FlattenTest.cs b/MoreLinq.Test/FlattenTest.cs index e1a8a5419..d9bf5a89d 100644 --- a/MoreLinq.Test/FlattenTest.cs +++ b/MoreLinq.Test/FlattenTest.cs @@ -405,18 +405,18 @@ public void FlattenSelectorWithTree() Assert.That(result, Is.EqualTo(expectations)); } - class Series + sealed class Series { public required string Name; public required Attribute[] Attributes; } - class Attribute + sealed class Attribute { public required int[] Values; } - class Tree + sealed class Tree { public readonly T Value; public readonly Tree? Left; diff --git a/MoreLinq.Test/FromTest.cs b/MoreLinq.Test/FromTest.cs index cee487dc0..2822011f0 100644 --- a/MoreLinq.Test/FromTest.cs +++ b/MoreLinq.Test/FromTest.cs @@ -20,7 +20,7 @@ namespace MoreLinq.Test using System; using NUnit.Framework; - class FromTest + public class FromTest { [Test] public void TestFromIsLazy() diff --git a/MoreLinq.Test/GenerateTest.cs b/MoreLinq.Test/GenerateTest.cs index 58657fc26..a9e60a8bb 100644 --- a/MoreLinq.Test/GenerateTest.cs +++ b/MoreLinq.Test/GenerateTest.cs @@ -61,7 +61,7 @@ public void GenerateByIndexIsLazy() [Test] public void GenerateByIndex() { - var sequence = MoreEnumerable.GenerateByIndex(x => x.ToString()).Take(3); + var sequence = MoreEnumerable.GenerateByIndex(x => x.ToInvariantString()).Take(3); sequence.AssertSequenceEqual("0", "1", "2"); } } diff --git a/MoreLinq.Test/InterleaveTest.cs b/MoreLinq.Test/InterleaveTest.cs index a8bfe4b56..945dc975f 100644 --- a/MoreLinq.Test/InterleaveTest.cs +++ b/MoreLinq.Test/InterleaveTest.cs @@ -85,7 +85,7 @@ public void TestInterleaveDisposesOnErrorAtMoveNext() [Test] public void TestInterleaveDoNotCallGetEnumeratorEagerly() { - var sequenceA = TestingSequence.Of(1); + using var sequenceA = TestingSequence.Of(1); var sequenceB = new BreakingSequence(); sequenceA.Interleave(sequenceB).Take(1).Consume(); diff --git a/MoreLinq.Test/MemoizeTest.cs b/MoreLinq.Test/MemoizeTest.cs index d498e5222..6cc0b6565 100644 --- a/MoreLinq.Test/MemoizeTest.cs +++ b/MoreLinq.Test/MemoizeTest.cs @@ -163,13 +163,14 @@ public void MemoizeDisposesAfterSourceIsIteratedEntirely() public static void MemoizeIsThreadSafe() { var sequence = Enumerable.Range(1, 50000); - var memoized = sequence.AsTestingSequence().Memoize(); + using var ts = sequence.AsTestingSequence(); + var memoized = ts.Memoize(); var lists = Enumerable.Range(0, Environment.ProcessorCount * 2) .Select(_ => new List()) .ToArray(); - var start = new Barrier(lists.Length); + using var start = new Barrier(lists.Length); var threads = from list in lists @@ -242,22 +243,24 @@ public void MemoizeWithMemoizedSourceReturnsSame() [Test] public void MemoizeRethrowsErrorDuringIterationToAllIteratorsUntilDisposed() { - var error = new Exception("This is a test exception."); + var error = new TestException("This is a test exception."); - var xs = MoreEnumerable.From(() => 123, () => throw error) - .AsTestingSequence(TestingSequence.Options.AllowMultipleEnumerations); + using var xs = MoreEnumerable.From(() => 123, () => throw error) + .AsTestingSequence(TestingSequence.Options.AllowMultipleEnumerations); var memoized = xs.Memoize(); - using ((IDisposable) memoized) + using ((IDisposable)memoized) using (var r1 = memoized.Read()) using (var r2 = memoized.Read()) { Assert.That(r1.Read(), Is.EqualTo(r2.Read())); - Assert.That(r1.Read, Throws.TypeOf().And.SameAs(error)); + Assert.That(r1.Read, Throws.TypeOf().And.SameAs(error)); Assert.That(xs.IsDisposed, Is.True); - Assert.That(r2.Read, Throws.TypeOf().And.SameAs(error)); + Assert.That(r2.Read, Throws.TypeOf().And.SameAs(error)); } + + using ((IDisposable)memoized) using (var r1 = memoized.Read()) Assert.That(r1.Read(), Is.EqualTo(123)); } @@ -265,23 +268,24 @@ public void MemoizeRethrowsErrorDuringIterationToAllIteratorsUntilDisposed() [Test] public void MemoizeRethrowsErrorDuringIterationStartToAllIteratorsUntilDisposed() { - var error = new Exception("This is a test exception."); + var error = new TestException("This is a test exception."); var i = 0; - var xs = MoreEnumerable.From(() => 0 == i++ - ? throw error // throw at start for first iteration only - : 42) - .AsTestingSequence(TestingSequence.Options.AllowMultipleEnumerations); + using var xs = MoreEnumerable.From(() => 0 == i++ + ? throw error // throw at start for first iteration only + : 42) + .AsTestingSequence(TestingSequence.Options.AllowMultipleEnumerations); var memoized = xs.Memoize(); - using ((IDisposable) memoized) + using ((IDisposable)memoized) using (var r1 = memoized.Read()) using (var r2 = memoized.Read()) { - Assert.That(r1.Read, Throws.TypeOf().And.SameAs(error)); + Assert.That(r1.Read, Throws.TypeOf().And.SameAs(error)); Assert.That(xs.IsDisposed, Is.True); - Assert.That(r2.Read, Throws.TypeOf().And.SameAs(error)); + Assert.That(r2.Read, Throws.TypeOf().And.SameAs(error)); } + using ((IDisposable)memoized) using (var r1 = memoized.Read()) using (var r2 = memoized.Read()) Assert.That(r1.Read(), Is.EqualTo(r2.Read())); @@ -290,7 +294,7 @@ public void MemoizeRethrowsErrorDuringIterationStartToAllIteratorsUntilDisposed( [Test] public void MemoizeRethrowsErrorDuringFirstIterationStartToAllIterationsUntilDisposed() { - var error = new Exception("An error on the first call!"); + var error = new TestException("An error on the first call!"); var obj = new object(); var calls = 0; var source = Delegate.Enumerable(() => 0 == calls++ @@ -300,7 +304,7 @@ public void MemoizeRethrowsErrorDuringFirstIterationStartToAllIterationsUntilDis var memo = source.Memoize(); for (var i = 0; i < 2; i++) - Assert.That(memo.First, Throws.TypeOf().And.SameAs(error)); + Assert.That(memo.First, Throws.TypeOf().And.SameAs(error)); ((IDisposable) memo).Dispose(); Assert.That(memo.Single(), Is.EqualTo(obj)); diff --git a/MoreLinq.Test/NullArgumentTest.cs b/MoreLinq.Test/NullArgumentTest.cs index dc65ad5ad..773bdd6b4 100644 --- a/MoreLinq.Test/NullArgumentTest.cs +++ b/MoreLinq.Test/NullArgumentTest.cs @@ -83,7 +83,10 @@ static IEnumerable CreateTestCases(MethodInfo methodDefinition, b return from param in parameters where IsReferenceType(param) && CanBeNull(param) == canBeNull let arguments = parameters.Select(p => p == param ? null : CreateInstance(p.ParameterType)).ToArray() - let testCase = testCaseFactory(method, arguments, param.Name ?? throw new NullReferenceException()) + let testCase = testCaseFactory(method, arguments, +#pragma warning disable CA2201 // Do not raise reserved exception types + param.Name ?? throw new NullReferenceException()) +#pragma warning restore CA2201 // Do not raise reserved exception types let testName = GetTestName(methodDefinition, param) select (ITestCaseData) new TestCaseData(testCase).SetName(testName); } @@ -209,7 +212,7 @@ public void Reset() { } // ReSharper disable UnusedMember.Local, UnusedAutoPropertyAccessor.Local static class GenericArgs { - class Enumerator : IEnumerator + sealed class Enumerator : IEnumerator { public bool MoveNext() => false; public T? Current { get; private set; } @@ -224,7 +227,9 @@ public class Enumerable : IEnumerable IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } - public class OrderedEnumerable : Enumerable, System.Linq.IOrderedEnumerable +#pragma warning disable CA1812 // Avoid uninstantiated internal classes + + public sealed class OrderedEnumerable : Enumerable, System.Linq.IOrderedEnumerable { public System.Linq.IOrderedEnumerable CreateOrderedEnumerable(Func keySelector, IComparer? comparer, bool descending) { @@ -233,23 +238,25 @@ public class OrderedEnumerable : Enumerable, System.Linq.IOrderedEnumerabl } } - public class AwaitQuery : Enumerable, - Experimental.IAwaitQuery + public sealed class AwaitQuery : Enumerable, + Experimental.IAwaitQuery { public Experimental.AwaitQueryOptions Options => Experimental.AwaitQueryOptions.Default; public Experimental.IAwaitQuery WithOptions(Experimental.AwaitQueryOptions options) => this; } - public class Comparer : IComparer + public sealed class Comparer : IComparer { public int Compare(T? x, T? y) => -1; } - public class EqualityComparer : IEqualityComparer + public sealed class EqualityComparer : IEqualityComparer { public bool Equals(T? x, T? y) => false; public int GetHashCode(T obj) => 0; } + +#pragma warning restore CA1812 // Avoid uninstantiated internal classes } } } diff --git a/MoreLinq.Test/OrderByTest.cs b/MoreLinq.Test/OrderByTest.cs index f8f06a2ce..8d4c2f6c0 100644 --- a/MoreLinq.Test/OrderByTest.cs +++ b/MoreLinq.Test/OrderByTest.cs @@ -18,6 +18,7 @@ namespace MoreLinq.Test { using System.Collections.Generic; + using System.Globalization; using NUnit.Framework; /// @@ -47,7 +48,7 @@ public void TestOrderBySelectorPreserved() } static readonly IComparer NumericStringComparer = - Comparer.Create((a, b) => int.Parse(a).CompareTo(int.Parse(b))); + Comparer.Create((a, b) => int.Parse(a, CultureInfo.InvariantCulture).CompareTo(int.Parse(b, CultureInfo.InvariantCulture))); /// /// Verify that OrderBy preserves the comparer @@ -56,7 +57,7 @@ public void TestOrderBySelectorPreserved() public void TestOrderByComparerPreserved() { var sequence = Enumerable.Range(1, 100); - var sequenceAscending = sequence.Select(x => x.ToString()); + var sequenceAscending = sequence.Select(x => x.ToInvariantString()); var sequenceDescending = sequenceAscending.Reverse(); var comparer = NumericStringComparer; diff --git a/MoreLinq.Test/OrderedMergeTest.cs b/MoreLinq.Test/OrderedMergeTest.cs index f2db2acb7..416e43c48 100644 --- a/MoreLinq.Test/OrderedMergeTest.cs +++ b/MoreLinq.Test/OrderedMergeTest.cs @@ -26,7 +26,7 @@ public class OrderedMergeTest { static IEnumerable Seq(params T[] values) => values; - public static IEnumerable TestData = + public static readonly IEnumerable TestData = from e in new[] { new diff --git a/MoreLinq.Test/PipeTest.cs b/MoreLinq.Test/PipeTest.cs index de119d50c..33eeb1f6c 100644 --- a/MoreLinq.Test/PipeTest.cs +++ b/MoreLinq.Test/PipeTest.cs @@ -48,7 +48,7 @@ public void PipeActionOccursBeforeYield() var source = new[] { new StringBuilder(), new StringBuilder() }; // The action will occur "in" the pipe, so by the time Where gets it, the // sequence will be empty. - Assert.That(source.Pipe(sb => sb.Append("x")) + Assert.That(source.Pipe(sb => sb.Append('x')) .Where(x => x.Length == 0), Is.Empty); } diff --git a/MoreLinq.Test/Program.cs b/MoreLinq.Test/Program.cs index 4044ef621..80f6ddf0d 100644 --- a/MoreLinq.Test/Program.cs +++ b/MoreLinq.Test/Program.cs @@ -24,8 +24,10 @@ namespace MoreLinq.Test static class Program { - static int Main(string[] args) => - new AutoRun(typeof(Program).GetTypeInfo().Assembly) - .Execute(args, new ExtendedTextWrapper(Console.Out), Console.In); + static int Main(string[] args) + { + using var writer = new ExtendedTextWrapper(Console.Out); + return new AutoRun(typeof(Program).GetTypeInfo().Assembly).Execute(args, writer, Console.In); + } } } diff --git a/MoreLinq.Test/RankTest.cs b/MoreLinq.Test/RankTest.cs index 381b8fd35..f63ec1def 100644 --- a/MoreLinq.Test/RankTest.cs +++ b/MoreLinq.Test/RankTest.cs @@ -52,7 +52,8 @@ public void TestRankByIsLazy() public void TestRankNullComparer() { var sequence = Enumerable.Repeat(1, 10); - sequence.AsTestingSequence().Rank(null).AssertSequenceEqual(sequence); + using var ts = sequence.AsTestingSequence(); + ts.Rank(null).AssertSequenceEqual(sequence); } /// @@ -62,7 +63,8 @@ public void TestRankNullComparer() public void TestRankByNullComparer() { var sequence = Enumerable.Repeat(1, 10); - sequence.AsTestingSequence().RankBy(x => x, null).AssertSequenceEqual(sequence); + using var ts = sequence.AsTestingSequence(); + ts.RankBy(x => x, null).AssertSequenceEqual(sequence); } /// @@ -73,8 +75,8 @@ public void TestRankByNullComparer() public void TestRankDescendingSequence() { const int count = 100; - var sequence = Enumerable.Range(456, count).Reverse(); - var result = sequence.AsTestingSequence().Rank().ToArray(); + using var sequence = Enumerable.Range(456, count).Reverse().AsTestingSequence(); + var result = sequence.Rank().ToArray(); var expectedResult = Enumerable.Range(1, count); Assert.That(result.Length, Is.EqualTo(count)); @@ -89,8 +91,8 @@ public void TestRankDescendingSequence() public void TestRankByAscendingSeries() { const int count = 100; - var sequence = Enumerable.Range(456, count); - var result = sequence.AsTestingSequence().Rank().ToArray(); + using var sequence = Enumerable.Range(456, count).AsTestingSequence(); + var result = sequence.Rank().ToArray(); var expectedResult = Enumerable.Range(1, count).Reverse(); Assert.That(result.Length, Is.EqualTo(count)); @@ -104,8 +106,8 @@ public void TestRankByAscendingSeries() public void TestRankEquivalentItems() { const int count = 100; - var sequence = Enumerable.Repeat(1234, count); - var result = sequence.AsTestingSequence().Rank().ToArray(); + using var sequence = Enumerable.Repeat(1234, count).AsTestingSequence(); + var result = sequence.Rank().ToArray(); Assert.That(result.Length, Is.EqualTo(count)); Assert.That(result, Is.EqualTo(Enumerable.Repeat(1, count))); @@ -121,7 +123,8 @@ public void TestRankGroupedItems() var sequence = Enumerable.Range(0, count) .Concat(Enumerable.Range(0, count)) .Concat(Enumerable.Range(0, count)); - var result = sequence.AsTestingSequence().Rank(); + using var ts = sequence.AsTestingSequence(); + var result = ts.Rank(); Assert.That(result.Distinct().Count(), Is.EqualTo(count)); Assert.That(result, Is.EqualTo(sequence.Reverse().Select(x => x + 1))); @@ -134,8 +137,8 @@ public void TestRankGroupedItems() public void TestRankOfHighestItemIsOne() { const int count = 10; - var sequence = Enumerable.Range(1, count); - var result = sequence.AsTestingSequence().Rank(); + using var sequence = Enumerable.Range(1, count).AsTestingSequence(); + var result = sequence.Rank(); Assert.That(result.OrderBy(x => x).First(), Is.EqualTo(1)); } @@ -157,7 +160,8 @@ public void TestRankByKeySelector() new { Name = "Jim", Age = 74, ExpectedRank = 1 }, new { Name = "Jes", Age = 11, ExpectedRank = 8 }, }; - var result = sequence.AsTestingSequence().RankBy(x => x.Age).ToArray(); + using var ts = sequence.AsTestingSequence(); + var result = ts.RankBy(x => x.Age).ToArray(); Assert.That(result.Length, Is.EqualTo(sequence.Length)); Assert.That(result, Is.EqualTo(sequence.Select(x => x.ExpectedRank))); @@ -173,8 +177,10 @@ public void TestRankCustomComparer() var ordinals = Enumerable.Range(1, count); var sequence = ordinals.Select( x => new DateTime(2010,x,20-x) ); // invert the CompareTo operation to Rank in reverse order (ascending to descending) - var resultA = sequence.AsTestingSequence().Rank(Comparer.Create((a, b) => -a.CompareTo(b))); - var resultB = sequence.AsTestingSequence().RankBy(x => x.Day, Comparer.Create((a, b) => -a.CompareTo(b))); + using var tsA = sequence.AsTestingSequence(); + var resultA = tsA.Rank(Comparer.Create((a, b) => -a.CompareTo(b))); + using var tsB = sequence.AsTestingSequence(); + var resultB = tsB.RankBy(x => x.Day, Comparer.Create((a, b) => -a.CompareTo(b))); Assert.That(resultA, Is.EqualTo(ordinals)); Assert.That(resultB, Is.EqualTo(ordinals.Reverse())); diff --git a/MoreLinq.Test/ReturnTest.cs b/MoreLinq.Test/ReturnTest.cs index 29d252632..21e1b4bea 100644 --- a/MoreLinq.Test/ReturnTest.cs +++ b/MoreLinq.Test/ReturnTest.cs @@ -22,7 +22,7 @@ namespace MoreLinq.Test using NUnit.Framework; using NUnit.Framework.Interfaces; - class ReturnTest + public class ReturnTest { static class SomeSingleton { diff --git a/MoreLinq.Test/ScanRightTest.cs b/MoreLinq.Test/ScanRightTest.cs index 45a21fe87..711f9ed68 100644 --- a/MoreLinq.Test/ScanRightTest.cs +++ b/MoreLinq.Test/ScanRightTest.cs @@ -62,7 +62,7 @@ public void ScanRightFuncIsNotInvokedOnSingleElementSequence() public void ScanRight(SourceKind sourceKind) { var result = Enumerable.Range(1, 5) - .Select(x => x.ToString()) + .Select(x => x.ToInvariantString()) .ToSourceKind(sourceKind) .ScanRight((a, b) => $"({a}+{b})"); diff --git a/MoreLinq.Test/SegmentTest.cs b/MoreLinq.Test/SegmentTest.cs index 44217e0b6..3ece846b5 100644 --- a/MoreLinq.Test/SegmentTest.cs +++ b/MoreLinq.Test/SegmentTest.cs @@ -170,7 +170,8 @@ from e in new[] [Test, TestCaseSource(nameof(TestData))] public IEnumerable> TestSegment(IEnumerable source) { - return source.AsTestingSequence().Segment(v => v % 3 == 0); + using var ts = source.AsTestingSequence(); + return ts.Segment(v => v % 3 == 0); } } } diff --git a/MoreLinq.Test/SkipUntilTest.cs b/MoreLinq.Test/SkipUntilTest.cs index a1c541b7b..373945869 100644 --- a/MoreLinq.Test/SkipUntilTest.cs +++ b/MoreLinq.Test/SkipUntilTest.cs @@ -77,7 +77,8 @@ from e in new[] [Test, TestCaseSource(nameof(TestData))] public int[] TestSkipUntil(int[] source, int min) { - return source.AsTestingSequence().SkipUntil(v => v >= min).ToArray(); + using var ts = source.AsTestingSequence(); + return ts.SkipUntil(v => v >= min).ToArray(); } } } diff --git a/MoreLinq.Test/TestException.cs b/MoreLinq.Test/TestException.cs index 7100f9ba6..98cb7c715 100644 --- a/MoreLinq.Test/TestException.cs +++ b/MoreLinq.Test/TestException.cs @@ -21,5 +21,9 @@ namespace MoreLinq.Test /// Reserved for use within tests. /// - sealed class TestException : System.Exception {} + sealed class TestException : System.Exception + { + public TestException() : this(null) { } + public TestException(string? message) : base(message) { } + } } diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs index 66f9399d1..e3696b222 100644 --- a/MoreLinq.Test/ToDataTableTest.cs +++ b/MoreLinq.Test/ToDataTableTest.cs @@ -29,7 +29,7 @@ namespace MoreLinq.Test [TestFixture] public class ToDataTableTest { - class TestObject + sealed class TestObject { public int KeyField; public Guid? ANullableGuidField; @@ -80,7 +80,7 @@ public void ToDataTableNullMemberExpressionMethod() [Test] public void ToDataTableTableWithWrongColumnNames() { - var dt = new DataTable(); + using var dt = new DataTable(); dt.Columns.Add("Test"); Assert.That(() => _testObjects.ToDataTable(dt), @@ -90,7 +90,7 @@ public void ToDataTableTableWithWrongColumnNames() [Test] public void ToDataTableTableWithWrongColumnDataType() { - var dt = new DataTable(); + using var dt = new DataTable(); dt.Columns.Add("AString", typeof(int)); Assert.That(() => _testObjects.ToDataTable(dt, t=>t.AString), @@ -170,7 +170,7 @@ public void ToDataTableWithExpression() [Test] public void ToDataTableWithSchema() { - var dt = new DataTable(); + using var dt = new DataTable(); var columns = dt.Columns; columns.Add("Column1", typeof(int)); columns.Add("Value", typeof(string)); @@ -192,7 +192,9 @@ public void ToDataTableWithSchema() struct Point { +#pragma warning disable CA1805 // Do not initialize unnecessarily (avoids CS0649) public static Point Empty = new Point(); +#pragma warning restore CA1805 // Do not initialize unnecessarily public bool IsEmpty => X == 0 && Y == 0; public int X { get; } public int Y { get; } diff --git a/MoreLinq.Test/TraverseTest.cs b/MoreLinq.Test/TraverseTest.cs index aa3ffb2db..3b9235e9b 100644 --- a/MoreLinq.Test/TraverseTest.cs +++ b/MoreLinq.Test/TraverseTest.cs @@ -50,7 +50,7 @@ public void TraverseBreadthFirstPreservesChildrenOrder() res.AssertSequenceEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10); } - class Tree + sealed class Tree { public T Value { get; } public IEnumerable> Children { get; } diff --git a/MoreLinq.Test/TrySingleTest.cs b/MoreLinq.Test/TrySingleTest.cs index 4fe51a3b2..5dfffbcaf 100644 --- a/MoreLinq.Test/TrySingleTest.cs +++ b/MoreLinq.Test/TrySingleTest.cs @@ -76,12 +76,14 @@ class BreakingSingleElementCollectionBase : IEnumerable protected BreakingSingleElementCollectionBase(T element) => _element = element; +#pragma warning disable CA1822 // Mark members as static public int Count => 1; +#pragma warning restore CA1822 // Mark members as static public IEnumerator GetEnumerator() { yield return _element; - throw new Exception($"{nameof(ExperimentalEnumerable.TrySingle)} should not have attempted to consume a second element."); + Assert.Fail($"{nameof(ExperimentalEnumerable.TrySingle)} should not have attempted to consume a second element."); } IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); @@ -128,7 +130,7 @@ static IEnumerable TestSequence() { yield return 1; yield return 2; - throw new Exception(nameof(ExperimentalEnumerable.TrySingle) + " should not have attempted to consume a third element."); + Assert.Fail(nameof(ExperimentalEnumerable.TrySingle) + " should not have attempted to consume a third element."); } var (cardinality, value) = TestSequence().TrySingle("zero", "one", "many"); diff --git a/MoreLinq.Test/ZipLongestTest.cs b/MoreLinq.Test/ZipLongestTest.cs index 24bd03a59..7c3faaec7 100644 --- a/MoreLinq.Test/ZipLongestTest.cs +++ b/MoreLinq.Test/ZipLongestTest.cs @@ -61,7 +61,7 @@ public void ZipLongestIsLazy() [Test] public void ZipLongestDisposeSequencesEagerly() { - var shorter = TestingSequence.Of(1, 2, 3); + using var shorter = TestingSequence.Of(1, 2, 3); var longer = MoreEnumerable.Generate(1, x => x + 1); var zipped = shorter.ZipLongest(longer, Tuple.Create); diff --git a/MoreLinq/EmptyArray.cs b/MoreLinq/EmptyArray.cs index 209912ee0..fa49b3567 100644 --- a/MoreLinq/EmptyArray.cs +++ b/MoreLinq/EmptyArray.cs @@ -2,6 +2,13 @@ namespace MoreLinq { static class EmptyArray { - public static readonly T[] Value = new T[0]; + public static readonly T[] Value = +#if NETSTANDARD1_6_OR_GREATER || NET6_0_OR_GREATER + System.Array.Empty(); +#else +#pragma warning disable CA1825 // Avoid zero-length array allocations + new T[0]; +#pragma warning restore CA1825 // Avoid zero-length array allocations +#endif } } diff --git a/MoreLinq/Experimental/Await.cs b/MoreLinq/Experimental/Await.cs index 779a5ed29..32656ebf5 100644 --- a/MoreLinq/Experimental/Await.cs +++ b/MoreLinq/Experimental/Await.cs @@ -148,8 +148,11 @@ static partial class ExperimentalEnumerable /// The source sequence. /// The converted sequence. - public static IEnumerable AsSequential(this IAwaitQuery source) => - source.MaxConcurrency(1); + public static IEnumerable AsSequential(this IAwaitQuery source) + { + if (source is null) throw new ArgumentNullException(nameof(source)); + return MaxConcurrency(source, 1); + } /// /// Returns a query whose results evaluate asynchronously to use a @@ -162,8 +165,11 @@ public static IEnumerable AsSequential(this IAwaitQuery source) => /// A query whose results evaluate asynchronously using the given /// concurrency limit. - public static IAwaitQuery MaxConcurrency(this IAwaitQuery source, int value) => - source.WithOptions(source.Options.WithMaxConcurrency(value)); + public static IAwaitQuery MaxConcurrency(this IAwaitQuery source, int value) + { + if (source is null) throw new ArgumentNullException(nameof(source)); + return source.WithOptions(source.Options.WithMaxConcurrency(value)); + } /// /// Returns a query whose results evaluate asynchronously and @@ -175,8 +181,11 @@ public static IAwaitQuery MaxConcurrency(this IAwaitQuery source, int v /// A query whose results evaluate asynchronously using no defined /// limitation on concurrency. - public static IAwaitQuery UnboundedConcurrency(this IAwaitQuery source) => - source.WithOptions(source.Options.WithMaxConcurrency(null)); + public static IAwaitQuery UnboundedConcurrency(this IAwaitQuery source) + { + if (source is null) throw new ArgumentNullException(nameof(source)); + return source.WithOptions(source.Options.WithMaxConcurrency(null)); + } /// /// Returns a query whose results evaluate asynchronously and uses the @@ -242,8 +251,11 @@ public static IAwaitQuery AsUnordered(this IAwaitQuery source) => /// results ordered or unordered based on . /// - public static IAwaitQuery PreserveOrder(this IAwaitQuery source, bool value) => - source.WithOptions(source.Options.WithPreserveOrder(value)); + public static IAwaitQuery PreserveOrder(this IAwaitQuery source, bool value) + { + if (source is null) throw new ArgumentNullException(nameof(source)); + return source.WithOptions(source.Options.WithPreserveOrder(value)); + } /// /// Creates a sequence query that streams the result of each task in @@ -461,13 +473,15 @@ IEnumerable _(int? maxConcurrency, TaskScheduler scheduler, bool ordere { try { - await enumerator.StartAsync( - e => evaluator(e.Value, cancellationToken), - (e, r) => PostNotice(Notice.Result, (e.Key, e.Value, r), default), - () => PostNotice(Notice.End, default, default), - maxConcurrency, cancellationToken); + await enumerator.StartAsync(e => evaluator(e.Value, cancellationToken), + (e, r) => PostNotice(Notice.Result, (e.Key, e.Value, r), default), + () => PostNotice(Notice.End, default, default), + maxConcurrency, cancellationToken) + .ConfigureAwait(false); } +#pragma warning disable CA1031 // Do not catch general exception types catch (Exception e) +#pragma warning restore CA1031 // Do not catch general exception types { PostNotice(Notice.Error, default, e); } @@ -527,9 +541,11 @@ void PostNotice(Notice notice, catch (OperationCanceledException e) when (e.CancellationToken == consumerCancellationTokenSource.Token) { var (error1, error2) = lastCriticalErrors; +#pragma warning disable CA2201 // Do not raise reserved exception types throw new Exception("One or more critical errors have occurred.", error2 != null ? new AggregateException(Assume.NotNull(error1), error2) : new AggregateException(Assume.NotNull(error1))); +#pragma warning restore CA2201 // Do not raise reserved exception types } var (kind, result, error) = notice.Current; @@ -644,7 +660,8 @@ void OnPendingCompleted() { try { - await concurrencyGate.EnterAsync(cancellationToken); + await concurrencyGate.EnterAsync(cancellationToken) + .ConfigureAwait(false); } catch (OperationCanceledException e) when (e.CancellationToken == cancellationToken) { @@ -731,13 +748,13 @@ static class CompletedTask { #if NET451 || NETSTANDARD1_0 - public static readonly Task Instance; + public static readonly Task Instance = CreateCompletedTask(); - static CompletedTask() + static Task CreateCompletedTask() { var tcs = new TaskCompletionSource(); tcs.SetResult(default); - Instance = tcs.Task; + return tcs.Task; } #else diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index e01aee1d9..964d46902 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -5205,6 +5205,7 @@ public static partial class SingleExtension /// The single element of the input sequence. /// +#pragma warning disable CA1720 // Identifier contains type name public static T Single(this IExtremaEnumerable source) => MoreEnumerable.Single(source); diff --git a/MoreLinq/Fold.cs b/MoreLinq/Fold.cs index 4b77b4856..93c2cefed 100644 --- a/MoreLinq/Fold.cs +++ b/MoreLinq/Fold.cs @@ -60,7 +60,9 @@ static TResult FoldImpl(IEnumerable source, int count, || count == 16 && folder16 == null ) { // ReSharper disable NotResolvedInText +#pragma warning disable CA2208 // Instantiate argument exceptions correctly throw new ArgumentNullException("folder"); // ReSharper restore NotResolvedInText +#pragma warning restore CA2208 // Instantiate argument exceptions correctly } var elements = new T[count]; diff --git a/MoreLinq/From.cs b/MoreLinq/From.cs index 5e6c35360..b9bf76faa 100644 --- a/MoreLinq/From.cs +++ b/MoreLinq/From.cs @@ -38,7 +38,9 @@ public static IEnumerable From(Func function) { return _(); IEnumerable _() { +#pragma warning disable CA1062 // Validate arguments of public methods yield return function(); +#pragma warning restore CA1062 // Validate arguments of public methods } } @@ -59,8 +61,10 @@ public static IEnumerable From(Func function1, Func function2) { return _(); IEnumerable _() { +#pragma warning disable CA1062 // Validate arguments of public methods yield return function1(); yield return function2(); +#pragma warning restore CA1062 // Validate arguments of public methods } } @@ -82,9 +86,11 @@ public static IEnumerable From(Func function1, Func function2, Func< { return _(); IEnumerable _() { +#pragma warning disable CA1062 // Validate arguments of public methods yield return function1(); yield return function2(); yield return function3(); +#pragma warning restore CA1062 // Validate arguments of public methods } } diff --git a/MoreLinq/GlobalRandom.cs b/MoreLinq/GlobalRandom.cs index 7aa165c62..900c2c5a2 100644 --- a/MoreLinq/GlobalRandom.cs +++ b/MoreLinq/GlobalRandom.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#pragma warning disable CA5394 // Do not use insecure randomness + namespace MoreLinq { using System; @@ -34,11 +36,16 @@ public static partial class MoreEnumerable /// On .NET 6+, delegates to Random.Shared. /// - sealed class GlobalRandom : Random - { + partial class GlobalRandom { } + #if NET6_0_OR_GREATER - public static Random Instance => Shared; -#else + static partial class GlobalRandom + { + public static Random Instance => System.Random.Shared; + } +#else // NET6_0_OR_GREATER + sealed partial class GlobalRandom : Random + { public static Random Instance { get; } = new GlobalRandom(); static int _seed = Environment.TickCount; @@ -65,7 +72,7 @@ protected override double Sample() throw new NotImplementedException(); } -#endif } +#endif // NET6_0_OR_GREATER } } diff --git a/MoreLinq/MaxBy.cs b/MoreLinq/MaxBy.cs index b9dbb1ac6..0ffe2f5de 100644 --- a/MoreLinq/MaxBy.cs +++ b/MoreLinq/MaxBy.cs @@ -142,7 +142,9 @@ public static T Last(this IExtremaEnumerable source) /// The single element of the input sequence. /// +#pragma warning disable CA1720 // Identifier contains type name public static T Single(this IExtremaEnumerable source) +#pragma warning restore CA1720 // Identifier contains type name { if (source == null) throw new ArgumentNullException(nameof(source)); return source.Take(2).AsEnumerable().Single(); diff --git a/MoreLinq/PendNode.cs b/MoreLinq/PendNode.cs index 9da48e859..65f53e20a 100644 --- a/MoreLinq/PendNode.cs +++ b/MoreLinq/PendNode.cs @@ -91,7 +91,7 @@ public IEnumerator GetEnumerator() case 1: concat2 = item.Value; break; case 2: concat3 = item.Value; break; case 3: concat4 = item.Value; break; - default: throw new IndexOutOfRangeException(); + default: throw new UnreachableException(); } continue; } diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs index a51359dc2..e60316179 100644 --- a/MoreLinq/Permutations.cs +++ b/MoreLinq/Permutations.cs @@ -129,7 +129,7 @@ public bool MoveNext() return prevResult; } - void IDisposable.Dispose() { } + void IDisposable.Dispose() => _generatorIterator.Dispose(); /// /// Transposes elements in the cached permutation array to produce the next permutation diff --git a/MoreLinq/Random.cs b/MoreLinq/Random.cs index 684fddef8..fd4c88757 100644 --- a/MoreLinq/Random.cs +++ b/MoreLinq/Random.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#pragma warning disable CA5394 // Do not use insecure randomness + namespace MoreLinq { using System; diff --git a/MoreLinq/RandomSubset.cs b/MoreLinq/RandomSubset.cs index 46a74aab5..d0716f57d 100644 --- a/MoreLinq/RandomSubset.cs +++ b/MoreLinq/RandomSubset.cs @@ -87,7 +87,9 @@ static IEnumerable RandomSubsetImpl(IEnumerable source, Random rand, Fu // perform in-place, partial Fisher-Yates shuffle while (m < subsetSize) { +#pragma warning disable CA5394 // Do not use insecure randomness var k = g - rand.Next(w); +#pragma warning restore CA5394 // Do not use insecure randomness (array[k], array[m]) = (array[m], array[k]); ++m; --w; diff --git a/MoreLinq/Repeat.cs b/MoreLinq/Repeat.cs index 3da6f838b..8e789b9cf 100644 --- a/MoreLinq/Repeat.cs +++ b/MoreLinq/Repeat.cs @@ -59,8 +59,12 @@ static IEnumerable RepeatImpl(IEnumerable sequence, int? count) { while (count == null || count-- > 0) { +#pragma warning disable CA1851 // Possible multiple enumerations of 'IEnumerable' collection foreach (var item in memo) +#pragma warning restore CA1851 // Possible multiple enumerations of 'IEnumerable' collection + { yield return item; + } } } } diff --git a/MoreLinq/Return.cs b/MoreLinq/Return.cs index a09a688c8..810ecd385 100644 --- a/MoreLinq/Return.cs +++ b/MoreLinq/Return.cs @@ -43,7 +43,7 @@ sealed class SingleElementList : IList, IReadOnlyList public T this[int index] { - get => index == 0 ? _item : throw new ArgumentOutOfRangeException(); + get => index == 0 ? _item : throw new ArgumentOutOfRangeException(nameof(index)); set => throw ReadOnlyException(); } diff --git a/MoreLinq/ToArrayByIndex.cs b/MoreLinq/ToArrayByIndex.cs index ad0f503c5..c4ff35474 100644 --- a/MoreLinq/ToArrayByIndex.cs +++ b/MoreLinq/ToArrayByIndex.cs @@ -126,16 +126,22 @@ public static TResult[] ToArrayByIndex(this IEnumerable source, foreach (var e in source) { - var i = indexSelector(e); - if (i < 0) - throw new IndexOutOfRangeException(); - lastIndex = Math.Max(i, lastIndex); - Indexed().Add(new KeyValuePair(i, e)); + switch (indexSelector(e)) + { + case < 0: +#pragma warning disable CA2201 // Do not raise reserved exception types + throw new IndexOutOfRangeException(); +#pragma warning restore CA2201 // Do not raise reserved exception types + case var i: + lastIndex = Math.Max(i, lastIndex); + Indexed().Add(new KeyValuePair(i, e)); + break; + } } var length = lastIndex + 1; return length == 0 - ? new TResult[0] + ? EmptyArray.Value : Indexed().ToArrayByIndex(length, e => e.Key, e => resultSelector(e.Value, e.Key)); } @@ -242,8 +248,14 @@ public static TResult[] ToArrayByIndex(this IEnumerable source, i foreach (var e in source) { var i = indexSelector(e); + if (i < 0 || i > array.Length) + { +#pragma warning disable CA2201 // Do not raise reserved exception types throw new IndexOutOfRangeException(); +#pragma warning restore CA2201 // Do not raise reserved exception types + } + array[i] = resultSelector(e, i); } return array; diff --git a/MoreLinq/Trace.cs b/MoreLinq/Trace.cs index 768f9b0f1..d7917a8c6 100644 --- a/MoreLinq/Trace.cs +++ b/MoreLinq/Trace.cs @@ -64,7 +64,7 @@ public static IEnumerable Trace(this IEnumerable sour return TraceImpl(source, string.IsNullOrEmpty(format) ? x => x?.ToString() ?? string.Empty - : x => string.Format(format, x)); + : x => string.Format(null, format, x)); } /// diff --git a/MoreLinq/UnreachableException.cs b/MoreLinq/UnreachableException.cs new file mode 100644 index 000000000..80e4cf0eb --- /dev/null +++ b/MoreLinq/UnreachableException.cs @@ -0,0 +1,58 @@ +#region License and Terms +// The MIT License (MIT) +// +// Copyright (c) .NET Foundation and Contributors +// +// All rights reserved. +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +#endregion + +#if !NET7_0_OR_GREATER + +namespace MoreLinq +{ + using System; + + // Source: https://github.com/dotnet/runtime/blob/v7.0.2/src/libraries/System.Private.CoreLib/src/System/Diagnostics/UnreachableException.cs + + /// + /// Exception thrown when the program executes an instruction that was thought to be unreachable. + /// + +#if !NETSTANDARD1_0 + [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage] +#endif +#pragma warning disable CA1064 // Exceptions should be public + sealed class UnreachableException : Exception +#pragma warning restore CA1064 // Exceptions should be public + { + public UnreachableException() : + this(null) { } + + public UnreachableException(string? message) : + base(message, null) { } + + public UnreachableException(string? message, Exception? innerException) : + base(message ?? "The program executed an instruction that was thought to be unreachable.", + innerException) { } + } +} + +#endif // !NET7_0_OR_GREATER diff --git a/bld/ExtensionsGenerator/Program.cs b/bld/ExtensionsGenerator/Program.cs index eda9301f1..03b85ab08 100644 --- a/bld/ExtensionsGenerator/Program.cs +++ b/bld/ExtensionsGenerator/Program.cs @@ -14,6 +14,8 @@ // #endregion +#pragma warning disable CA2201 // Do not raise reserved exception types + using System; using System.Collections.Generic; using System.Collections.Immutable; @@ -27,12 +29,18 @@ using Microsoft.CodeAnalysis.CSharp.Syntax; using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +// Disable CA1852 due to the following false negative: +// Type 'Program' can be sealed because it has no subtypes in its containing assembly and is not externally visible +#pragma warning disable CA1852 // Seal internal types try +#pragma warning restore CA1852 // Seal internal types { Run(args); return 0; } +#pragma warning disable CA1031 // Do not catch general exception types catch (Exception e) +#pragma warning restore CA1031 // Do not catch general exception types { Console.Error.WriteLine(e.ToString()); return 0xbad; @@ -330,8 +338,8 @@ namespace MoreLinq.Extensions Console.WriteLine(template.Trim() // normalize line endings - .Replace("\r", string.Empty) - .Replace("\n", Environment.NewLine)); + .Replace("\r", string.Empty, StringComparison.Ordinal) + .Replace("\n", Environment.NewLine, StringComparison.Ordinal)); } static TypeKey CreateTypeKey(TypeSyntax root, Func abbreviator) From 60ec000dc02f56c4c140900b4e4d66785be98c74 Mon Sep 17 00:00:00 2001 From: Orace Date: Tue, 17 Jan 2023 12:28:10 +0100 Subject: [PATCH 034/157] Test additional cases for "TagFirstLast" --- MoreLinq.Test/TagFirstLastTest.cs | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/MoreLinq.Test/TagFirstLastTest.cs b/MoreLinq.Test/TagFirstLastTest.cs index 0dcf9928c..b4bf9cb46 100644 --- a/MoreLinq.Test/TagFirstLastTest.cs +++ b/MoreLinq.Test/TagFirstLastTest.cs @@ -22,12 +22,29 @@ namespace MoreLinq.Test [TestFixture] public class TagFirstLastTest { + [Test] + public void TagFirstLastDoesOneLookAhead() + { + var source = MoreEnumerable.From(() => 123, () => 456, BreakingFunc.Of()); + source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast }) + .Take(1) + .Consume(); + } + [Test] public void TagFirstLastIsLazy() { new BreakingSequence().TagFirstLast(BreakingFunc.Of()); } + [Test] + public void TagFirstLastWithSourceSequenceOfZero() + { + var source = Enumerable.Empty(); + var sut = source.TagFirstLast(BreakingFunc.Of()); + Assert.That(sut, Is.Empty); + } + [Test] public void TagFirstLastWithSourceSequenceOfOne() { From 728bca9f2f9f06820df8257a738ea002fe7f34eb Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Wed, 18 Jan 2023 00:01:59 +0100 Subject: [PATCH 035/157] Fix off-by-one index validation bug in "ToArrayByIndex" Fixes #931. --- MoreLinq.Test/ToArrayByIndexTest.cs | 2 +- MoreLinq/ToArrayByIndex.cs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/MoreLinq.Test/ToArrayByIndexTest.cs b/MoreLinq.Test/ToArrayByIndexTest.cs index 27d3567c4..fcc02f64e 100644 --- a/MoreLinq.Test/ToArrayByIndexTest.cs +++ b/MoreLinq.Test/ToArrayByIndexTest.cs @@ -83,7 +83,7 @@ public void ToArrayByIndexWithLengthWithBadIndexSelectorThrows(int length, int b Assert.That(() => input.ToArrayByIndex(length, _ => badIndex), Throws.TypeOf()); - Assert.That(() => input.ToArrayByIndex(10, _ => -1, BreakingFunc.Of()), + Assert.That(() => input.ToArrayByIndex(length, _ => badIndex, BreakingFunc.Of()), Throws.TypeOf()); } diff --git a/MoreLinq/ToArrayByIndex.cs b/MoreLinq/ToArrayByIndex.cs index c4ff35474..5fa513ab5 100644 --- a/MoreLinq/ToArrayByIndex.cs +++ b/MoreLinq/ToArrayByIndex.cs @@ -249,7 +249,7 @@ public static TResult[] ToArrayByIndex(this IEnumerable source, i { var i = indexSelector(e); - if (i < 0 || i > array.Length) + if (i < 0 || i >= array.Length) { #pragma warning disable CA2201 // Do not raise reserved exception types throw new IndexOutOfRangeException(); From fd10ce01ed306812fbd8cafd5da19a48b572a470 Mon Sep 17 00:00:00 2001 From: Orace Date: Wed, 18 Jan 2023 15:08:18 +0100 Subject: [PATCH 036/157] Decompose "TagFirstLast" implementation for speed (#643) --- MoreLinq.Test/TagFirstLastTest.cs | 36 +++++++++++++++++-------------- MoreLinq/TagFirstLast.cs | 20 +++++++++++++++-- 2 files changed, 38 insertions(+), 18 deletions(-) diff --git a/MoreLinq.Test/TagFirstLastTest.cs b/MoreLinq.Test/TagFirstLastTest.cs index b4bf9cb46..484904a9d 100644 --- a/MoreLinq.Test/TagFirstLastTest.cs +++ b/MoreLinq.Test/TagFirstLastTest.cs @@ -25,10 +25,10 @@ public class TagFirstLastTest [Test] public void TagFirstLastDoesOneLookAhead() { - var source = MoreEnumerable.From(() => 123, () => 456, BreakingFunc.Of()); - source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast }) - .Take(1) - .Consume(); + using var source = MoreEnumerable.From(() => 123, () => 456, BreakingFunc.Of()).AsTestingSequence(); + var result = source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast }); + + result.Take(1).Consume(); } [Test] @@ -40,34 +40,38 @@ public void TagFirstLastIsLazy() [Test] public void TagFirstLastWithSourceSequenceOfZero() { - var source = Enumerable.Empty(); - var sut = source.TagFirstLast(BreakingFunc.Of()); - Assert.That(sut, Is.Empty); + using var source = Enumerable.Empty().AsTestingSequence(); + var result = source.TagFirstLast(BreakingFunc.Of()); + + Assert.That(result, Is.Empty); } [Test] public void TagFirstLastWithSourceSequenceOfOne() { - var source = new[] { 123 }; - source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast }) - .AssertSequenceEqual(new { Item = 123, IsFirst = true, IsLast = true }); + using var source = new[] { 123 }.AsTestingSequence(); + var result = source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast }); + + result.AssertSequenceEqual(new { Item = 123, IsFirst = true, IsLast = true }); } [Test] public void TagFirstLastWithSourceSequenceOfTwo() { - var source = new[] { 123, 456 }; - source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast }) - .AssertSequenceEqual(new { Item = 123, IsFirst = true, IsLast = false }, + using var source = new[] { 123, 456 }.AsTestingSequence(); + var result = source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast }); + + result.AssertSequenceEqual(new { Item = 123, IsFirst = true, IsLast = false }, new { Item = 456, IsFirst = false, IsLast = true }); } [Test] public void TagFirstLastWithSourceSequenceOfThree() { - var source = new[] { 123, 456, 789 }; - source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast }) - .AssertSequenceEqual(new { Item = 123, IsFirst = true, IsLast = false }, + using var source = new[] { 123, 456, 789 }.AsTestingSequence(); + var result = source.TagFirstLast((item, isFirst, isLast) => new { Item = item, IsFirst = isFirst, IsLast = isLast }); + + result.AssertSequenceEqual(new { Item = 123, IsFirst = true, IsLast = false }, new { Item = 456, IsFirst = false, IsLast = false }, new { Item = 789, IsFirst = false, IsLast = true }); } diff --git a/MoreLinq/TagFirstLast.cs b/MoreLinq/TagFirstLast.cs index e37367582..61d90f6e7 100644 --- a/MoreLinq/TagFirstLast.cs +++ b/MoreLinq/TagFirstLast.cs @@ -59,8 +59,24 @@ public static IEnumerable TagFirstLast(this IEnumerab if (source == null) throw new ArgumentNullException(nameof(source)); if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return source.Index() // count-up - .CountDown(1, (e, cd) => resultSelector(e.Value, e.Key == 0, cd == 0)); + return _(); IEnumerable _() + { + using var enumerator = source.GetEnumerator(); + + if (!enumerator.MoveNext()) + yield break; + + var current = enumerator.Current; + var hasNext = enumerator.MoveNext(); + yield return resultSelector(current, true, !hasNext); + + while (hasNext) + { + current = enumerator.Current; + hasNext = enumerator.MoveNext(); + yield return resultSelector(current, false, !hasNext); + } + } } } } From 9ba27f68b4fd819aa9d0f8a2697443cd728ec1f4 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 19 Jan 2023 00:05:05 +0100 Subject: [PATCH 037/157] Update docs build tools --- MoreLinq.shfbproj | 63 ++++++++++++++++++++++++++++------------------- README.md | 6 ++--- msbuild.cmd | 10 +++----- 3 files changed, 45 insertions(+), 34 deletions(-) diff --git a/MoreLinq.shfbproj b/MoreLinq.shfbproj index 26ada71e4..92e3b25c4 100644 --- a/MoreLinq.shfbproj +++ b/MoreLinq.shfbproj @@ -1,5 +1,6 @@ - - + + + Documentation Documentation Documentation + .NET Core/.NET Standard/.NET 5.0+ .\docs\api\ Help en-US MoreLINQ fills in a few gaps left by LINQ to Objects. + Website + Standard + Default2022 + True + True + False + False + OnlyWarningsAndErrors + 100 - - + + Website http://www.apache.org/licenses/LICENSE-2.0 @@ -30,26 +41,16 @@ MoreLinq Google Groups MoreLinq MemberName + AboveNamespaces + False + False + 2 False - - - - - - - - - VS2013 - .NET Framework 4.0 + Blank - - Provides types and extension methods that extend LINQ to Objects. - - Provides experimental types and extension methods that extend LINQ to Objects. + + Provides types and extension methods that extend LINQ to Objects. + Provides experimental types and extension methods that extend LINQ to Objects. THE METHODS ARE EXPERIMENTAL. @@ -63,6 +64,7 @@ THE METHODS ARE PUBLISHED FOR FIELD EXPERIMENTATION TO SOLICIT FEEDBACK ON THEIR UTILITY AND DESIGN/IMPLEMENTATION DEFECTS. + - + + + + + + + + + + + OnBuildSuccess + diff --git a/README.md b/README.md index 0104175ee..e3ba59bb4 100644 --- a/README.md +++ b/README.md @@ -74,11 +74,11 @@ Building the documentation is supported on Windows only and requires [Sandcastle Help File Builder (SHFB)][shfb]. Executing `builddocs.cmd` generates the documentation in the `docs/api` directory. It can be browsed locally using any HTTP server of static files, like -[http-server][http-server]. +[dotnet-serve][dotnet-serve]. [dotnet-linux]: https://learn.microsoft.com/en-us/dotnet/core/install/linux -[shfb]: https://github.com/EWSoftware/SHFB/releases/tag/v2017.12.30.2 -[http-server]: https://www.npmjs.com/package/http-server +[shfb]: https://github.com/EWSoftware/SHFB/releases/tag/v2022.12.30.0 +[dotnet-serve]: https://www.nuget.org/packages/dotnet-serve [t4]: https://docs.microsoft.com/en-us/visualstudio/modeling/code-generation-and-t4-text-templates diff --git a/msbuild.cmd b/msbuild.cmd index f24ead479..406eea283 100644 --- a/msbuild.cmd +++ b/msbuild.cmd @@ -1,10 +1,8 @@ @echo off setlocal -if "%PROCESSOR_ARCHITECTURE%"=="x86" set PROGRAMS=%ProgramFiles% -if defined ProgramFiles(x86) set PROGRAMS=%ProgramFiles(x86)% for %%e in (Community Professional Enterprise) do ( - if exist "%PROGRAMS%\Microsoft Visual Studio\2019\%%e\MSBuild\Current\Bin\MSBuild.exe" ( - set "MSBUILD=%PROGRAMS%\Microsoft Visual Studio\2019\%%e\MSBuild\Current\Bin\MSBuild.exe" + if exist "%ProgramFiles%\Microsoft Visual Studio\2022\%%e\MSBuild\Current\Bin\MSBuild.exe" ( + set "MSBUILD=%ProgramFiles%\Microsoft Visual Studio\2022\%%e\MSBuild\Current\Bin\MSBuild.exe" ) ) if exist "%MSBUILD%" goto :build @@ -17,13 +15,13 @@ for /f "delims=. tokens=1,2,3,4" %%m in ('msbuild /version /nologo') do ( set MSBUILD_VERSION_MAJOR=%%m ) if not defined MSBUILD_VERSION_MAJOR goto :nomsbuild -if %MSBUILD_VERSION_MAJOR% lss 16 goto :nomsbuild +if %MSBUILD_VERSION_MAJOR% lss 17 goto :nomsbuild :build "%MSBUILD%" %* goto :EOF :nomsbuild -echo>&2 Microsoft Build Engine 16.0 or a later version is required to build +echo>&2 Microsoft Build Engine 17.0 or a later version is required to build echo>&2 the solution. For installation instructions, see: echo>&2 https://docs.microsoft.com/en-us/visualstudio/install/use-command-line-parameters-to-install-visual-studio echo>&2 At the very least, you will want to install the MSBuilt Tool workload From 74b0bcc48fb219ebfe91479195a99ca769ed18af Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 19 Jan 2023 21:24:06 +0100 Subject: [PATCH 038/157] Updated .NET Framework target to 4.6.2 > Support for .NET Framework versions 4.5.2, 4.6, and 4.6.1 ended on > April 26, 2022, so security fixes, updates, and technical support > for these versions will no longer be provided. > > Source: https://dotnet.microsoft.com/en-us/platform/support/policy/dotnet-framework --- MoreLinq.Test/CurrentThreadCultureScope.cs | 4 ---- MoreLinq.Test/MoreLinq.Test.csproj | 8 ++++---- MoreLinq/Experimental/Await.cs | 2 +- MoreLinq/MoreLinq.csproj | 8 ++++---- test.cmd | 8 ++++---- test.sh | 2 +- 6 files changed, 14 insertions(+), 18 deletions(-) diff --git a/MoreLinq.Test/CurrentThreadCultureScope.cs b/MoreLinq.Test/CurrentThreadCultureScope.cs index 4a5dad3ce..e647a2822 100644 --- a/MoreLinq.Test/CurrentThreadCultureScope.cs +++ b/MoreLinq.Test/CurrentThreadCultureScope.cs @@ -34,11 +34,7 @@ protected override void Restore(CultureInfo old) static void Install(CultureInfo value) { -#if NET451 - System.Threading.Thread.CurrentThread.CurrentCulture = value; -#else CultureInfo.CurrentCulture = value; -#endif } } } diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index f2eff7fd3..da095895b 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -2,7 +2,7 @@ MoreLinq.Test - net7.0;net6.0;netcoreapp3.1;net451 + net7.0;net6.0;netcoreapp3.1;net462 portable MoreLinq.Test Exe @@ -48,11 +48,11 @@ - + - + @@ -64,7 +64,7 @@ - + diff --git a/MoreLinq/Experimental/Await.cs b/MoreLinq/Experimental/Await.cs index 32656ebf5..92a00bbc0 100644 --- a/MoreLinq/Experimental/Await.cs +++ b/MoreLinq/Experimental/Await.cs @@ -746,7 +746,7 @@ static class TupleComparer static class CompletedTask { - #if NET451 || NETSTANDARD1_0 + #if NETSTANDARD1_0 public static readonly Task Instance = CreateCompletedTask(); diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 2dc1c2a92..b07b9a2bd 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -119,7 +119,7 @@ en-US 3.3.2 MoreLINQ Developers. - net451;netstandard1.0;netstandard2.0;netstandard2.1;net6.0 + net462;netstandard1.0;netstandard2.0;netstandard2.1;net6.0 false @@ -180,7 +180,7 @@ - + @@ -191,7 +191,7 @@ $(DefineConstants);MORELINQ - + $(DefineConstants);NO_BUFFERS @@ -204,7 +204,7 @@ - + diff --git a/test.cmd b/test.cmd index 97648ec5c..7f87f56c0 100644 --- a/test.cmd +++ b/test.cmd @@ -14,8 +14,8 @@ call build ^ && call :test net6.0 Release ^ && call :test netcoreapp3.1 Debug ^ && call :test netcoreapp3.1 Release ^ - && call :test net451 Debug ^ - && call :test net451 Release ^ + && call :test net462 Debug ^ + && call :test net462 Release ^ && call :report-cover goto :EOF @@ -30,8 +30,8 @@ goto :EOF setlocal cd MoreLinq.Test echo Testing %1 (%2)... -if %1==net451 ( - bin\%2\net451\MoreLinq.Test.exe +if %1==net462 ( + bin\%2\net462\MoreLinq.Test.exe exit /b %ERRORLEVEL% ) dotnet test --no-build -f %1 -c %2 --settings coverlet.runsettings || exit /b 1 diff --git a/test.sh b/test.sh index 772991688..c228eabe2 100755 --- a/test.sh +++ b/test.sh @@ -26,6 +26,6 @@ if [[ -z `which mono 2>/dev/null` ]]; then echo>&2 against the Mono runtime will be skipped. else for c in $configs; do - mono MoreLinq.Test/bin/$c/net451/MoreLinq.Test.exe + mono MoreLinq.Test/bin/$c/net462/MoreLinq.Test.exe done fi From c08119796f4e32d35802195ef03d473d2b606cd8 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Wed, 6 Jan 2021 22:32:13 +0100 Subject: [PATCH 039/157] Remove redundant type spec on obvious new expressions --- MoreLinq.Test/KeyValuePair.cs | 3 +-- MoreLinq.Test/ReturnTest.cs | 2 +- MoreLinq.Test/SampleData.cs | 12 ++++++++---- MoreLinq.Test/ShuffleTest.cs | 2 +- MoreLinq.Test/ToDataTableTest.cs | 10 +++------- MoreLinq.Test/TraverseTest.cs | 3 +-- MoreLinq.Test/WatchableEnumerator.cs | 3 +-- MoreLinq/Experimental/Await.cs | 9 ++++----- MoreLinq/GroupAdjacent.cs | 2 +- MoreLinq/Return.cs | 3 +-- 10 files changed, 22 insertions(+), 27 deletions(-) diff --git a/MoreLinq.Test/KeyValuePair.cs b/MoreLinq.Test/KeyValuePair.cs index ee9a44dc0..82493f0d0 100644 --- a/MoreLinq.Test/KeyValuePair.cs +++ b/MoreLinq.Test/KeyValuePair.cs @@ -21,7 +21,6 @@ namespace MoreLinq.Test static class KeyValuePair { - public static KeyValuePair Create(TKey key, TValue value) => - new KeyValuePair(key, value); + public static KeyValuePair Create(TKey key, TValue value) => new(key, value); } } diff --git a/MoreLinq.Test/ReturnTest.cs b/MoreLinq.Test/ReturnTest.cs index 21e1b4bea..fda98990b 100644 --- a/MoreLinq.Test/ReturnTest.cs +++ b/MoreLinq.Test/ReturnTest.cs @@ -26,7 +26,7 @@ public class ReturnTest { static class SomeSingleton { - public static readonly object Item = new object(); + public static readonly object Item = new(); public static readonly IEnumerable Sequence = MoreEnumerable.Return(Item); public static IList List => (IList)Sequence; public static ICollection Collection => (ICollection)Sequence; diff --git a/MoreLinq.Test/SampleData.cs b/MoreLinq.Test/SampleData.cs index df74bed9b..6e257d060 100644 --- a/MoreLinq.Test/SampleData.cs +++ b/MoreLinq.Test/SampleData.cs @@ -25,11 +25,15 @@ namespace MoreLinq.Test /// static class SampleData { - internal static readonly ReadOnlyCollection Strings = new ReadOnlyCollection( - new[] { "ax", "hello", "world", "aa", "ab", "ay", "az" }); + internal static readonly ReadOnlyCollection Strings = new(new[] + { + "ax", "hello", "world", "aa", "ab", "ay", "az" + }); - internal static readonly ReadOnlyCollection Values = - new ReadOnlyCollection(new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }); + internal static readonly ReadOnlyCollection Values = new(new[] + { + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 + }); internal static readonly Func Plus = (a, b) => a + b; internal static readonly Func Mul = (a, b) => a * b; diff --git a/MoreLinq.Test/ShuffleTest.cs b/MoreLinq.Test/ShuffleTest.cs index cd9769d86..eeb82edc0 100644 --- a/MoreLinq.Test/ShuffleTest.cs +++ b/MoreLinq.Test/ShuffleTest.cs @@ -23,7 +23,7 @@ namespace MoreLinq.Test [TestFixture] public class ShuffleTest { - static Random seed = new Random(12345); + static Random seed = new(12345); [Test] public void ShuffleIsLazy() diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs index e3696b222..e800dd7c0 100644 --- a/MoreLinq.Test/ToDataTableTest.cs +++ b/MoreLinq.Test/ToDataTableTest.cs @@ -38,12 +38,7 @@ sealed class TestObject public decimal? ANullableDecimal { get; } public object Unreadable { set => throw new NotImplementedException(); } - public object this[int index] - { - get => new object(); - set { } - } - + public object this[int index] { get => new(); set { } } public TestObject(int key) { @@ -192,8 +187,9 @@ public void ToDataTableWithSchema() struct Point { + #pragma warning disable CA1805 // Do not initialize unnecessarily (avoids CS0649) - public static Point Empty = new Point(); + public static Point Empty = new(); #pragma warning restore CA1805 // Do not initialize unnecessarily public bool IsEmpty => X == 0 && Y == 0; public int X { get; } diff --git a/MoreLinq.Test/TraverseTest.cs b/MoreLinq.Test/TraverseTest.cs index 3b9235e9b..07736d9ac 100644 --- a/MoreLinq.Test/TraverseTest.cs +++ b/MoreLinq.Test/TraverseTest.cs @@ -64,8 +64,7 @@ public Tree(T value, IEnumerable> children) static class Tree { - public static Tree New(T value, params Tree[] children) => - new Tree(value, children); + public static Tree New(T value, params Tree[] children) => new(value, children); } [Test] diff --git a/MoreLinq.Test/WatchableEnumerator.cs b/MoreLinq.Test/WatchableEnumerator.cs index 2756df448..cb6b14bef 100644 --- a/MoreLinq.Test/WatchableEnumerator.cs +++ b/MoreLinq.Test/WatchableEnumerator.cs @@ -23,8 +23,7 @@ namespace MoreLinq.Test partial class TestExtensions { - public static WatchableEnumerator AsWatchable(this IEnumerator source) => - new WatchableEnumerator(source); + public static WatchableEnumerator AsWatchable(this IEnumerator source) => new(source); } sealed class WatchableEnumerator : IEnumerator diff --git a/MoreLinq/Experimental/Await.cs b/MoreLinq/Experimental/Await.cs index 92a00bbc0..54433155b 100644 --- a/MoreLinq/Experimental/Await.cs +++ b/MoreLinq/Experimental/Await.cs @@ -40,10 +40,9 @@ public sealed class AwaitQueryOptions /// asynchronously. /// - public static readonly AwaitQueryOptions Default = - new AwaitQueryOptions(null /* = unbounded concurrency */, - TaskScheduler.Default, - preserveOrder: false); + public static readonly AwaitQueryOptions Default = new(null /* = unbounded concurrency */, + TaskScheduler.Default, + preserveOrder: false); /// /// Gets a positive (non-zero) integer that specifies the maximum @@ -766,7 +765,7 @@ static Task CreateCompletedTask() sealed class ConcurrencyGate { - public static readonly ConcurrencyGate Unbounded = new ConcurrencyGate(); + public static readonly ConcurrencyGate Unbounded = new(); readonly SemaphoreSlim? _semaphore; diff --git a/MoreLinq/GroupAdjacent.cs b/MoreLinq/GroupAdjacent.cs index 08bd069a6..162d23735 100644 --- a/MoreLinq/GroupAdjacent.cs +++ b/MoreLinq/GroupAdjacent.cs @@ -301,7 +301,7 @@ static IGrouping CreateGroupAdjacentGrouping(TKe static class Grouping { public static Grouping Create(TKey key, IEnumerable members) => - new Grouping(key, members); + new(key, members); } #if !NO_SERIALIZATION_ATTRIBUTES diff --git a/MoreLinq/Return.cs b/MoreLinq/Return.cs index 810ecd385..35ffa3adc 100644 --- a/MoreLinq/Return.cs +++ b/MoreLinq/Return.cs @@ -63,8 +63,7 @@ public T this[int index] public void Insert(int index, T item) => throw ReadOnlyException(); public void RemoveAt(int index) => throw ReadOnlyException(); - static NotSupportedException ReadOnlyException() => - new NotSupportedException("Single element list is immutable."); + static NotSupportedException ReadOnlyException() => new("Single element list is immutable."); } } } From d56bc49b25276ed94eef560c3c1e7b85bc625606 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Fri, 20 Jan 2023 23:54:39 +0100 Subject: [PATCH 040/157] Use testing sequence in "Pairwise" test Closes #650. --- MoreLinq.Test/PairwiseTest.cs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/MoreLinq.Test/PairwiseTest.cs b/MoreLinq.Test/PairwiseTest.cs index d810ea9fa..f205d99a3 100644 --- a/MoreLinq.Test/PairwiseTest.cs +++ b/MoreLinq.Test/PairwiseTest.cs @@ -41,7 +41,8 @@ public void PairwiseWithSequenceShorterThanTwo(int count) [Test] public void PairwiseWideSourceSequence() { - var result = new[] { "a", "b", "c", "d" }.Pairwise((x, y) => x + y); + using var source = new[] { "a", "b", "c", "d" }.AsTestingSequence(); + var result = source.Pairwise((x, y) => x + y); result.AssertSequenceEqual("ab", "bc", "cd"); } } From 3734e83a4204e80efa4cc91f5047aa7caa861aaf Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 21 Jan 2023 00:59:11 +0100 Subject: [PATCH 041/157] Declare & set modifier preference (IDE0040) severity --- .editorconfig | 4 ++++ MoreLinq/Lookup.cs | 2 ++ 2 files changed, 6 insertions(+) diff --git a/.editorconfig b/.editorconfig index 46779ac64..91ca08d50 100644 --- a/.editorconfig +++ b/.editorconfig @@ -57,3 +57,7 @@ csharp_space_between_method_declaration_parameter_list_parentheses = false # Wrapping csharp_preserve_single_line_statements = true csharp_preserve_single_line_blocks = true + +# Modifier preferences +dotnet_style_require_accessibility_modifiers = omit_if_default +dotnet_diagnostic.IDE0040.severity = warning diff --git a/MoreLinq/Lookup.cs b/MoreLinq/Lookup.cs index a25b104ec..bf31984e1 100644 --- a/MoreLinq/Lookup.cs +++ b/MoreLinq/Lookup.cs @@ -24,6 +24,8 @@ // SOFTWARE. #endregion +#pragma warning disable IDE0040 // Add accessibility modifiers + namespace MoreLinq { using System; From 62914fb870b41c3e7e067cd88b21c5aeda67f432 Mon Sep 17 00:00:00 2001 From: Orace Date: Sat, 21 Jan 2023 01:46:23 +0100 Subject: [PATCH 042/157] Fix "Exclude" to not call "MoveNext" post iteration This is a squashed merge of PR #692 that fixes #665. Co-authored-by: Atif Aziz --- MoreLinq.Test/ExcludeTest.cs | 29 +++++++++++++++++------------ MoreLinq/Exclude.cs | 18 ++++++++++++++---- 2 files changed, 31 insertions(+), 16 deletions(-) diff --git a/MoreLinq.Test/ExcludeTest.cs b/MoreLinq.Test/ExcludeTest.cs index 07e54cb2a..ff87a8545 100644 --- a/MoreLinq.Test/ExcludeTest.cs +++ b/MoreLinq.Test/ExcludeTest.cs @@ -60,7 +60,7 @@ public void TestExcludeNegativeCountException() [Test] public void TestExcludeWithCountEqualsZero() { - var sequence = Enumerable.Range(1, 10); + using var sequence = Enumerable.Range(1, 10).AsTestingSequence(); var resultA = sequence.Exclude(5, 0); Assert.That(resultA, Is.SameAs(sequence)); @@ -88,10 +88,11 @@ public void TestExcludeEmptySequence() public void TestExcludeSequenceHead() { const int count = 10; - var sequence = Enumerable.Range(1, count); + var xs = Enumerable.Range(1, count); + using var sequence = xs.AsTestingSequence(); var result = sequence.Exclude(0, count / 2); - Assert.That(result, Is.EqualTo(sequence.Skip(count / 2))); + Assert.That(result, Is.EqualTo(xs.Skip(count / 2))); } /// @@ -101,10 +102,11 @@ public void TestExcludeSequenceHead() public void TestExcludeSequenceTail() { const int count = 10; - var sequence = Enumerable.Range(1, count); + var xs = Enumerable.Range(1, count); + using var sequence = xs.AsTestingSequence(); var result = sequence.Exclude(count / 2, count); - Assert.That(result, Is.EqualTo(sequence.Take(count / 2))); + Assert.That(result, Is.EqualTo(xs.Take(count / 2))); } /// @@ -116,10 +118,11 @@ public void TestExcludeSequenceMiddle() const int count = 10; const int startIndex = 3; const int excludeCount = 5; - var sequence = Enumerable.Range(1, count); + var xs = Enumerable.Range(1, count); + using var sequence = xs.AsTestingSequence(); var result = sequence.Exclude(startIndex, excludeCount); - Assert.That(result, Is.EqualTo(sequence.Take(startIndex).Concat(sequence.Skip(startIndex + excludeCount)))); + Assert.That(result, Is.EqualTo(xs.Take(startIndex).Concat(xs.Skip(startIndex + excludeCount)))); } /// @@ -129,7 +132,7 @@ public void TestExcludeSequenceMiddle() public void TestExcludeEntireSequence() { const int count = 10; - var sequence = Enumerable.Range(1, count); + using var sequence = Enumerable.Range(1, count).AsTestingSequence(); var result = sequence.Exclude(0, count); Assert.That(result, Is.Empty); @@ -142,10 +145,11 @@ public void TestExcludeEntireSequence() public void TestExcludeCountGreaterThanSequenceLength() { const int count = 10; - var sequence = Enumerable.Range(1, count); + var xs = Enumerable.Range(1, count); + using var sequence = xs.AsTestingSequence(); var result = sequence.Exclude(1, count * 10); - Assert.That(result, Is.EqualTo(sequence.Take(1))); + Assert.That(result, Is.EqualTo(xs.Take(1))); } /// @@ -155,10 +159,11 @@ public void TestExcludeCountGreaterThanSequenceLength() public void TestExcludeStartIndexGreaterThanSequenceLength() { const int count = 10; - var sequence = Enumerable.Range(1, count); + var xs = Enumerable.Range(1, count); + using var sequence = xs.AsTestingSequence(); var result = sequence.Exclude(count + 5, count); - Assert.That(result, Is.EqualTo(sequence)); + Assert.That(result, Is.EqualTo(xs)); } } } diff --git a/MoreLinq/Exclude.cs b/MoreLinq/Exclude.cs index 4e3d7edc9..455861862 100644 --- a/MoreLinq/Exclude.cs +++ b/MoreLinq/Exclude.cs @@ -46,15 +46,25 @@ public static IEnumerable Exclude(this IEnumerable sequence, int startI IEnumerable _() { - var index = -1; + var index = 0; var endIndex = startIndex + count; using var iter = sequence.GetEnumerator(); + // yield the first part of the sequence - while (iter.MoveNext() && ++index < startIndex) + for (; index < startIndex; index++) + { + if (!iter.MoveNext()) + yield break; yield return iter.Current; + } + // skip the next part (up to count items) - while (++index < endIndex && iter.MoveNext()) - continue; + for (; index < endIndex; index++) + { + if (!iter.MoveNext()) + yield break; + } + // yield the remainder of the sequence while (iter.MoveNext()) yield return iter.Current; From c76db183f9d86732083223cce16464d256dfe5b2 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 21 Jan 2023 19:22:22 +0100 Subject: [PATCH 043/157] Fix home when setting path during CI build --- appveyor.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/appveyor.yml b/appveyor.yml index 4cff2558c..4d8cbda7a 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -58,7 +58,7 @@ install: - sh: ./tools/dotnet-install.sh --jsonfile global.json - sh: ./tools/dotnet-install.sh --runtime dotnet --version 3.1.10 --skip-non-versioned-files - sh: ./tools/dotnet-install.sh --runtime dotnet --version 6.0.11 --skip-non-versioned-files -- sh: export PATH="~/.dotnet:$PATH" +- sh: export PATH="$HOME/.dotnet:$PATH" before_build: - dotnet --info build_script: From 0be76fdba6970dde3c62f50391491dca86f28e0d Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 21 Jan 2023 22:05:06 +0100 Subject: [PATCH 044/157] Revert "Integrate templated code generation into project file (#776)" (#940) This reverts commit f669558facbbec9269a466c81594d5db8a19b4d1. --- MoreLinq/MoreLinq.csproj | 30 ------------------------------ MoreLinq/tt.cmd | 8 ++++++++ MoreLinq/tt.sh | 4 ++++ build.cmd | 1 + build.sh | 1 + 5 files changed, 14 insertions(+), 30 deletions(-) create mode 100644 MoreLinq/tt.cmd create mode 100755 MoreLinq/tt.sh diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index b07b9a2bd..b357ef6c4 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -157,7 +157,6 @@ - TextTemplatingFileGenerator Aggregate.g.cs @@ -248,33 +247,4 @@ - - - - %(None.LastGenOutput) - - - - - - - - - - - - - - - - - - - - - diff --git a/MoreLinq/tt.cmd b/MoreLinq/tt.cmd new file mode 100644 index 000000000..cbb7ac281 --- /dev/null +++ b/MoreLinq/tt.cmd @@ -0,0 +1,8 @@ +@echo off +pushd "%~dp0" +for /f "tokens=*" %%f in ('dir /s /b *.tt') do ( + echo>&2 dotnet t4 "%%f" + dotnet t4 "%%f" || goto :end +) +:end +popd diff --git a/MoreLinq/tt.sh b/MoreLinq/tt.sh new file mode 100755 index 000000000..49be91c70 --- /dev/null +++ b/MoreLinq/tt.sh @@ -0,0 +1,4 @@ +#!/usr/bin/env bash +set -e +cd "$(dirname "$0")" +find . -name "*.tt" -print0 | xargs -0 -t -L 1 sh -c '(dotnet t4 "$0" || exit 255)' diff --git a/build.cmd b/build.cmd index 18923a015..ae3dbc0db 100644 --- a/build.cmd +++ b/build.cmd @@ -13,6 +13,7 @@ if "%1"=="docs" shift & goto :docs dotnet restore && dotnet tool restore ^ && call :codegen MoreLinq\Extensions.g.cs -x "[/\\]ToDataTable\.cs$" -u System.Linq -u System.Collections MoreLinq ^ && call :codegen MoreLinq\Extensions.ToDataTable.g.cs -i "[/\\]ToDataTable\.cs$" -u System.Data -u System.Linq.Expressions MoreLinq ^ + && call MoreLinq\tt ^ && for %%i in (debug release) do dotnet build -c %%i --no-restore %* || exit /b 1 goto :EOF diff --git a/build.sh b/build.sh index 7d188c377..ac7f75b51 100755 --- a/build.sh +++ b/build.sh @@ -12,6 +12,7 @@ codegen() { } codegen MoreLinq/Extensions.g.cs -x "[/\\\\]ToDataTable\.cs$" -u System.Linq -u System.Collections MoreLinq codegen MoreLinq/Extensions.ToDataTable.g.cs -i "[/\\\\]ToDataTable\.cs$" -u System.Data -u System.Linq.Expressions MoreLinq +MoreLinq/tt.sh if [[ -z "$1" ]]; then configs="Debug Release" else From d587f73402701db9b4c79ae17204b4382e768893 Mon Sep 17 00:00:00 2001 From: Avi Levin Date: Sun, 22 Jan 2023 23:00:09 +0200 Subject: [PATCH 045/157] Simplify tests for count family of methods This is a squashed merge of PR #507 that closes #445. Co-authored-by: Avi Levin Co-authored-by: Atif Aziz --- MoreLinq.Test/AtLeastTest.cs | 82 ++++++++----------------------- MoreLinq.Test/AtMostTest.cs | 60 +++++++--------------- MoreLinq.Test/CompareCountTest.cs | 63 +++++------------------- MoreLinq.Test/CountBetweenTest.cs | 32 ++++++------ MoreLinq.Test/CountDownTest.cs | 2 +- MoreLinq.Test/ExactlyTest.cs | 41 ++++++---------- MoreLinq.Test/TestExtensions.cs | 27 +++++++--- 7 files changed, 108 insertions(+), 199 deletions(-) diff --git a/MoreLinq.Test/AtLeastTest.cs b/MoreLinq.Test/AtLeastTest.cs index f4ad24f88..83f6093ad 100644 --- a/MoreLinq.Test/AtLeastTest.cs +++ b/MoreLinq.Test/AtLeastTest.cs @@ -18,6 +18,7 @@ namespace MoreLinq.Test { using NUnit.Framework; + using System.Collections.Generic; [TestFixture] public class AtLeastTest @@ -29,68 +30,27 @@ public void AtLeastWithNegativeCount() Throws.ArgumentOutOfRangeException("count")); } - [Test] - public void AtLeastWithEmptySequenceHasAtLeastZeroElements() - { - foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.That(xs.AtLeast(0), Is.True); - } - - [Test] - public void AtLeastWithEmptySequenceHasAtLeastOneElement() - { - foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.That(xs.AtLeast(1), Is.False); - } - - [Test] - public void AtLeastWithEmptySequenceHasAtLeastManyElements() - { - foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.That(xs.AtLeast(2), Is.False); - } - - [Test] - public void AtLeastWithSingleElementHasAtLeastZeroElements() - { - foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.That(xs.AtLeast(0), Is.True); - } - - [Test] - public void AtLeastWithSingleElementHasAtLeastOneElement() - { - foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.That(xs.AtLeast(1), Is.True); - } + public static IEnumerable AtLeastSource => + from k in SourceKinds.Sequence.Concat(SourceKinds.Collection) + from e in new[] + { + (Size: 0, Count: 0), + (Size: 0, Count: 1), + (Size: 0, Count: 2), + (Size: 1, Count: 0), + (Size: 1, Count: 1), + (Size: 1, Count: 2), + (Size: 3, Count: 0), + (Size: 3, Count: 1), + (Size: 3, Count: 2) + } + select new TestCaseData(k, e.Size, e.Count) + .Returns(e.Size >= e.Count) + .SetName($"{{m}}({k}[{e.Size}], {e.Count})"); - [Test] - public void AtLeastWithSingleElementHasAtLeastManyElements() - { - foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.That(xs.AtLeast(2), Is.False); - } - - [Test] - public void AtLeastWithManyElementsHasAtLeastZeroElements() - { - foreach (var xs in new[] { 1, 2, 3 }.ArrangeCollectionTestCases()) - Assert.That(xs.AtLeast(0), Is.True); - } - - [Test] - public void AtLeastWithManyElementsHasAtLeastOneElement() - { - foreach (var xs in new[] { 1, 2, 3 }.ArrangeCollectionTestCases()) - Assert.That(xs.AtLeast(1), Is.True); - } - - [Test] - public void AtLeastWithManyElementsHasAtLeastManyElements() - { - foreach (var xs in new[] { 1, 2, 3 }.ArrangeCollectionTestCases()) - Assert.That(xs.AtLeast(2), Is.True); - } + [TestCaseSource(nameof(AtLeastSource))] + public bool AtLeast(SourceKind sourceKind, int sequenceSize, int atLeastAssertCount) => + Enumerable.Range(0, sequenceSize).ToSourceKind(sourceKind).AtLeast(atLeastAssertCount); [Test] public void AtLeastDoesNotIterateUnnecessaryElements() diff --git a/MoreLinq.Test/AtMostTest.cs b/MoreLinq.Test/AtMostTest.cs index 14135b930..74e3add7a 100644 --- a/MoreLinq.Test/AtMostTest.cs +++ b/MoreLinq.Test/AtMostTest.cs @@ -18,6 +18,7 @@ namespace MoreLinq.Test { using NUnit.Framework; + using System.Collections.Generic; [TestFixture] public class AtMostTest @@ -29,47 +30,24 @@ public void AtMostWithNegativeCount() Throws.ArgumentOutOfRangeException("count")); } - [Test] - public void AtMostWithEmptySequenceHasAtMostZeroElements() - { - foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.That(xs.AtMost(0), Is.True); - } - - [Test] - public void AtMostWithEmptySequenceHasAtMostOneElement() - { - foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.That(xs.AtMost(1), Is.True); - } - - [Test] - public void AtMostWithSingleElementHasAtMostZeroElements() - { - foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.That(xs.AtMost(0), Is.False); - } - - [Test] - public void AtMostWithSingleElementHasAtMostOneElement() - { - foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.That(xs.AtMost(1), Is.True); - } - - [Test] - public void AtMostWithSingleElementHasAtMostManyElements() - { - foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.That(xs.AtMost(2), Is.True); - } - - [Test] - public void AtMostWithManyElementsHasAtMostOneElements() - { - foreach (var xs in new[] { 1, 2, 3 }.ArrangeCollectionTestCases()) - Assert.That(xs.AtMost(1), Is.False); - } + public static IEnumerable AtMostSource => + from k in SourceKinds.Sequence.Concat(SourceKinds.Collection) + from e in new[] + { + (Size: 0, Count: 0), + (Size: 0, Count: 1), + (Size: 1, Count: 0), + (Size: 1, Count: 1), + (Size: 1, Count: 2), + (Size: 3, Count: 1) + } + select new TestCaseData(k, e.Size, e.Count) + .Returns(e.Size <= e.Count) + .SetName($"{{m}}({k}[{e.Size}], {e.Count})"); + + [TestCaseSource(nameof(AtMostSource))] + public bool AtMost(SourceKind sourceKind, int sequenceSize, int atMostAssertCount) => + Enumerable.Range(0, sequenceSize).ToSourceKind(sourceKind).AtMost(atMostAssertCount); [Test] public void AtMostDoesNotIterateUnnecessaryElements() diff --git a/MoreLinq.Test/CompareCountTest.cs b/MoreLinq.Test/CompareCountTest.cs index 906749bf6..5f0386b88 100644 --- a/MoreLinq.Test/CompareCountTest.cs +++ b/MoreLinq.Test/CompareCountTest.cs @@ -17,28 +17,28 @@ namespace MoreLinq.Test { - using System; using System.Collections.Generic; using NUnit.Framework; [TestFixture] public class CompareCountTest { - static readonly IEnumerable CompareCountData = + static IEnumerable CompareCountData => from e in new[] { - new { Count1 = 0, Count2 = 0, Comparison = 0 }, - new { Count1 = 0, Count2 = 1, Comparison = -1 }, - new { Count1 = 1, Count2 = 0, Comparison = 1 }, - new { Count1 = 1, Count2 = 1, Comparison = 0 }, + (Count1: 0, Count2: 0, Comparison: 0 ), + (Count1: 0, Count2: 1, Comparison: -1 ), + (Count1: 1, Count2: 0, Comparison: 1 ), + (Count1: 1, Count2: 1, Comparison: 0 ) } - from s in GetTestSequenceKinds( - Enumerable.Range(1, e.Count1), - Enumerable.Range(1, e.Count2), - (xs, ys) => new { First = xs, Second = ys }) - select new TestCaseData(s.First.Data, s.Second.Data) - .Returns(e.Comparison) - .SetName($"{{m}}({s.First.Kind}[{e.Count1}], {s.Second.Kind}[{e.Count2}]) = {e.Comparison}"); + from firstKind in SourceKinds.Sequence.Concat(SourceKinds.Collection) + from secondKind in SourceKinds.Sequence.Concat(SourceKinds.Collection) + select new TestCaseData( + Enumerable.Range(1, e.Count1).ToSourceKind(firstKind), + Enumerable.Range(1, e.Count2).ToSourceKind(secondKind)) + .Returns(e.Comparison) + .SetName($"{{m}}({firstKind}[{e.Count1}], {secondKind}[{e.Count2}]) = {e.Comparison}"); + [TestCaseSource(nameof(CompareCountData))] public int CompareCount(IEnumerable xs, IEnumerable ys) => @@ -138,42 +138,5 @@ public void CompareCountDoesNotIterateUnnecessaryElements() Assert.That(seq1.CompareCount(seq2), Is.EqualTo( 1)); Assert.That(seq2.CompareCount(seq1), Is.EqualTo(-1)); } - - enum SequenceKind - { - Sequence, - Collection, - ReadOnlyCollection, - } - - static IEnumerable GetTestSequenceKinds( - IEnumerable s1, IEnumerable s2, - Func<(IEnumerable Data, SequenceKind Kind), - (IEnumerable Data, SequenceKind Kind), TResult> selector) - { - // Test that the operator is optimized for collections - - var s1Seq = (s1.Select(x => x), SequenceKind.Sequence); - var s2Seq = (s2.Select(x => x), SequenceKind.Sequence); - - var s1Col = (s1.ToSourceKind(SourceKind.BreakingCollection), SequenceKind.Collection); - var s2Col = (s2.ToSourceKind(SourceKind.BreakingCollection), SequenceKind.Collection); - - var s1ReadOnlyCol = (s1.ToSourceKind(SourceKind.BreakingReadOnlyCollection), SequenceKind.ReadOnlyCollection); - var s2ReadOnlyCol = (s2.ToSourceKind(SourceKind.BreakingReadOnlyCollection), SequenceKind.ReadOnlyCollection); - - // sequences - yield return selector(s1Seq, s2Seq); - - // sequences and collections - yield return selector(s1Seq, s2Col); - yield return selector(s1Col, s2Seq); - yield return selector(s1Col, s2Col); - - // sequences and readOnlyCollections - yield return selector(s1Seq, s2ReadOnlyCol); - yield return selector(s1ReadOnlyCol, s2Seq); - yield return selector(s1ReadOnlyCol, s2ReadOnlyCol); - } } } diff --git a/MoreLinq.Test/CountBetweenTest.cs b/MoreLinq.Test/CountBetweenTest.cs index 6e57ba32c..93d51e19d 100644 --- a/MoreLinq.Test/CountBetweenTest.cs +++ b/MoreLinq.Test/CountBetweenTest.cs @@ -18,6 +18,7 @@ namespace MoreLinq.Test { using NUnit.Framework; + using System.Collections.Generic; [TestFixture] public class CountBetweenTest @@ -43,22 +44,25 @@ public void CountBetweenWithMaxLesserThanMin() Throws.ArgumentOutOfRangeException("max")); } - [Test] - public void CountBetweenWithMaxEqualsMin() - { - foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.That(xs.CountBetween(1, 1), Is.True); - } + static IEnumerable CountBetweenSource => + from args in new[] + { + (Count: 1, Min: 1, Max: 1), + (Count: 1, Min: 2, Max: 4), + (Count: 2, Min: 2, Max: 4), + (Count: 3, Min: 2, Max: 4), + (Count: 4, Min: 2, Max: 4), + (Count: 5, Min: 2, Max: 4), + } + from type in SourceKinds.Sequence.Concat(SourceKinds.Collection) + select new TestCaseData(type, args.Count, args.Min, args.Max) + .Returns(args.Count >= args.Min && args.Count <= args.Max) + .SetName($"{{m}}({type}[{args.Count}], {args.Min}, {args.Max})"); - [TestCase(1, 2, 4, false)] - [TestCase(2, 2, 4, true)] - [TestCase(3, 2, 4, true)] - [TestCase(4, 2, 4, true)] - [TestCase(5, 2, 4, false)] - public void CountBetweenRangeTests(int count, int min, int max, bool expecting) + [TestCaseSource(nameof(CountBetweenSource))] + public bool CountBetween(SourceKind sourceKind, int count, int min, int max) { - foreach (var xs in Enumerable.Range(1, count).ArrangeCollectionTestCases()) - Assert.That(xs.CountBetween(min, max), Is.EqualTo(expecting)); + return Enumerable.Range(0, count).ToSourceKind(sourceKind).CountBetween(min, max); } [Test] diff --git a/MoreLinq.Test/CountDownTest.cs b/MoreLinq.Test/CountDownTest.cs index a1862116e..a28153d33 100644 --- a/MoreLinq.Test/CountDownTest.cs +++ b/MoreLinq.Test/CountDownTest.cs @@ -77,7 +77,7 @@ static IEnumerable GetData(Func selector) { Source = xs, Count = count, Countdown = countdown }) - from kind in new[] { SourceKind.BreakingList, SourceKind.BreakingReadOnlyList } + from kind in SourceKinds.List select new TestCaseData(e.Source.ToSourceKind(kind), e.Count) .Returns(e.Source.Zip(e.Countdown, ValueTuple.Create)) .SetName($"{nameof(WithList)}({kind} {{ {string.Join(", ", e.Source)} }}, {e.Count})"); diff --git a/MoreLinq.Test/ExactlyTest.cs b/MoreLinq.Test/ExactlyTest.cs index 0d765d139..f1858d34d 100644 --- a/MoreLinq.Test/ExactlyTest.cs +++ b/MoreLinq.Test/ExactlyTest.cs @@ -18,6 +18,7 @@ namespace MoreLinq.Test { using NUnit.Framework; + using System.Collections.Generic; [TestFixture] public class ExactlyTest @@ -29,33 +30,23 @@ public void ExactlyWithNegativeCount() Throws.ArgumentOutOfRangeException("count")); } - [Test] - public void ExactlyWithEmptySequenceHasExactlyZeroElements() - { - foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.That(xs.Exactly(0), Is.True); - } + static IEnumerable ExactlySource => + from k in SourceKinds.Sequence.Concat(SourceKinds.Collection) + from e in new[] + { + (Size: 0, Count: 0), + (Size: 0, Count: 1), + (Size: 1, Count: 1), + (Size: 3, Count: 1) + } + select new TestCaseData(k, e.Size, e.Count) + .Returns(e.Size == e.Count) + .SetName($"{{m}}({k}[{e.Size}], {e.Count})"); - [Test] - public void ExactlyWithEmptySequenceHasExactlyOneElement() - { - foreach (var xs in Enumerable.Empty().ArrangeCollectionTestCases()) - Assert.That(xs.Exactly(1), Is.False); - } + [TestCaseSource(nameof(ExactlySource))] + public bool Exactly(SourceKind sourceKind, int sequenceSize, int exactlyAssertCount) => + Enumerable.Range(0, sequenceSize).ToSourceKind(sourceKind).Exactly(exactlyAssertCount); - [Test] - public void ExactlyWithSingleElementHasExactlyOneElements() - { - foreach (var xs in new[] { 1 }.ArrangeCollectionTestCases()) - Assert.That(xs.Exactly(1), Is.True); - } - - [Test] - public void ExactlyWithManyElementHasExactlyOneElement() - { - foreach (var xs in new[] { 1, 2, 3 }.ArrangeCollectionTestCases()) - Assert.That(xs.Exactly(1), Is.False); - } [Test] public void ExactlyDoesNotIterateUnnecessaryElements() diff --git a/MoreLinq.Test/TestExtensions.cs b/MoreLinq.Test/TestExtensions.cs index b6e12aee2..0cb95b4e2 100644 --- a/MoreLinq.Test/TestExtensions.cs +++ b/MoreLinq.Test/TestExtensions.cs @@ -31,6 +31,26 @@ public enum SourceKind BreakingReadOnlyCollection } + static class SourceKinds + { + public static readonly IEnumerable Sequence = new[] + { + SourceKind.Sequence, + }; + + public static readonly IEnumerable Collection = new[] + { + SourceKind.BreakingCollection, + SourceKind.BreakingReadOnlyCollection + }; + + public static readonly IEnumerable List = new[] + { + SourceKind.BreakingList, + SourceKind.BreakingReadOnlyList + }; + } + static partial class TestExtensions { /// @@ -67,13 +87,6 @@ internal static IEnumerable GenerateSplits(this string str, params char[ yield return split; } - internal static IEnumerable> ArrangeCollectionTestCases(this IEnumerable input) - { - yield return input.ToSourceKind(SourceKind.Sequence); - yield return input.ToSourceKind(SourceKind.BreakingReadOnlyCollection); - yield return input.ToSourceKind(SourceKind.BreakingCollection); - } - internal static IEnumerable ToSourceKind(this IEnumerable input, SourceKind sourceKind) { return sourceKind switch From 9c17aae35a5d8194776bc348028e78b36c023d6b Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 24 Jan 2023 08:41:45 +0100 Subject: [PATCH 046/157] Improve optimisation for a list source in "CountDown" --- MoreLinq/CountDown.cs | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/MoreLinq/CountDown.cs b/MoreLinq/CountDown.cs index a46186a89..1f5f72dad 100644 --- a/MoreLinq/CountDown.cs +++ b/MoreLinq/CountDown.cs @@ -65,15 +65,11 @@ public static IEnumerable CountDown(this IEnumerable sou IEnumerable IterateList(IListLike list) { - var countdown = Math.Min(count, list.Count); + var listCount = list.Count; + var countdown = Math.Min(count, listCount); - for (var i = 0; i < list.Count; i++) - { - var cd = list.Count - i <= count - ? --countdown - : (int?) null; - yield return resultSelector(list[i], cd); - } + for (var i = 0; i < listCount; i++) + yield return resultSelector(list[i], listCount - i <= count ? --countdown : null); } IEnumerable IterateCollection(int i) From 5b4947169707a137ec3da4703834b25175f90908 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 24 Jan 2023 21:13:58 +0100 Subject: [PATCH 047/157] Enforce and address code style issues --- .editorconfig | 57 +++++++++---- MoreLinq.Test/.editorconfig | 8 ++ MoreLinq.Test/AcquireTest.cs | 2 +- MoreLinq.Test/AggregateTest.cs | 6 +- MoreLinq.Test/AppendTest.cs | 4 +- MoreLinq.Test/AssertCountTest.cs | 6 +- MoreLinq.Test/AssertTest.cs | 8 +- MoreLinq.Test/Async/AsyncEnumerable.cs | 8 +- MoreLinq.Test/BacksertTest.cs | 2 +- MoreLinq.Test/BatchTest.cs | 2 +- MoreLinq.Test/BreakingCollection.cs | 2 +- MoreLinq.Test/BreakingList.cs | 4 +- MoreLinq.Test/BreakingReadOnlyCollection.cs | 2 +- MoreLinq.Test/BreakingReadOnlyList.cs | 4 +- MoreLinq.Test/CartesianTest.cs | 7 +- MoreLinq.Test/ChooseTest.cs | 5 +- MoreLinq.Test/CountByTest.cs | 2 +- MoreLinq.Test/CountDownTest.cs | 6 +- MoreLinq.Test/CurrentThreadCultureScope.cs | 16 +--- MoreLinq.Test/DistinctByTest.cs | 6 +- MoreLinq.Test/EndsWithTest.cs | 22 ++--- MoreLinq.Test/EqualityComparer.cs | 2 +- MoreLinq.Test/EquiZipTest.cs | 2 +- MoreLinq.Test/EvaluateTest.cs | 2 +- MoreLinq.Test/ExceptByTest.cs | 6 +- MoreLinq.Test/ExcludeTest.cs | 2 +- MoreLinq.Test/FillBackwardTest.cs | 2 +- MoreLinq.Test/FillForwardTest.cs | 2 +- MoreLinq.Test/FlattenTest.cs | 8 +- MoreLinq.Test/FromTest.cs | 10 +-- MoreLinq.Test/FullGroupJoinTest.cs | 2 +- MoreLinq.Test/GenerateTest.cs | 4 +- MoreLinq.Test/GroupAdjacentTest.cs | 12 +-- MoreLinq.Test/IndexByTest.cs | 2 +- MoreLinq.Test/IndexTest.cs | 4 +- MoreLinq.Test/InsertTest.cs | 2 +- MoreLinq.Test/InterleaveTest.cs | 2 +- MoreLinq.Test/LagTest.cs | 4 +- MoreLinq.Test/LeadTest.cs | 4 +- MoreLinq.Test/MaxByTest.cs | 2 +- MoreLinq.Test/MemoizeTest.cs | 10 +-- MoreLinq.Test/MinByTest.cs | 2 +- MoreLinq.Test/MoreLinq.Test.csproj | 5 +- MoreLinq.Test/MoveTest.cs | 2 +- MoreLinq.Test/NullArgumentTest.cs | 24 +++--- MoreLinq.Test/PadStartTest.cs | 6 +- MoreLinq.Test/PadTest.cs | 4 +- MoreLinq.Test/PairwiseTest.cs | 2 +- MoreLinq.Test/PartialSortByTest.cs | 2 +- MoreLinq.Test/PartialSortTest.cs | 2 +- MoreLinq.Test/PartitionTest.cs | 2 +- MoreLinq.Test/PermutationsTest.cs | 2 +- MoreLinq.Test/PipeTest.cs | 2 +- MoreLinq.Test/PreScanTest.cs | 2 +- MoreLinq.Test/PrependTest.cs | 4 +- MoreLinq.Test/Program.cs | 23 ++--- MoreLinq.Test/RandomSubsetTest.cs | 6 +- MoreLinq.Test/RankTest.cs | 6 +- MoreLinq.Test/RepeatTest.cs | 4 +- MoreLinq.Test/ReturnTest.cs | 2 +- MoreLinq.Test/RunLengthEncodeTest.cs | 4 +- MoreLinq.Test/ScanByTest.cs | 8 +- MoreLinq.Test/ScanRightTest.cs | 4 +- MoreLinq.Test/ScanTest.cs | 6 +- MoreLinq.Test/Scope.cs | 12 +-- MoreLinq.Test/SegmentTest.cs | 6 +- MoreLinq.Test/ShuffleTest.cs | 12 +-- MoreLinq.Test/SkipLastTest.cs | 2 +- MoreLinq.Test/SkipUntilTest.cs | 2 +- MoreLinq.Test/SliceTest.cs | 2 +- MoreLinq.Test/SortedMergeTest.cs | 2 +- MoreLinq.Test/StartsWithTest.cs | 22 ++--- MoreLinq.Test/SubjectTest.cs | 94 ++++++++++++--------- MoreLinq.Test/SubsetTest.cs | 4 +- MoreLinq.Test/TagFirstLastTest.cs | 2 +- MoreLinq.Test/TakeEveryTest.cs | 2 +- MoreLinq.Test/TakeLastTest.cs | 4 +- MoreLinq.Test/TakeUntilTest.cs | 2 +- MoreLinq.Test/TestExtensions.cs | 6 +- MoreLinq.Test/ToDataTableTest.cs | 24 +++--- MoreLinq.Test/TraceTest.cs | 4 +- MoreLinq.Test/TransposeTest.cs | 2 +- MoreLinq.Test/TraverseTest.cs | 4 +- MoreLinq.Test/TrySingleTest.cs | 4 +- MoreLinq.Test/UnfoldTest.cs | 8 +- MoreLinq.Test/WindowLeftTest.cs | 26 +++--- MoreLinq.Test/WindowRightTest.cs | 26 +++--- MoreLinq.Test/WindowTest.cs | 26 +++--- MoreLinq.Test/ZipLongestTest.cs | 4 +- MoreLinq.Test/ZipShortestTest.cs | 2 +- MoreLinq/AggregateRight.cs | 11 ++- MoreLinq/AssemblyInfo.cs | 5 +- MoreLinq/AssertCount.cs | 26 +++--- MoreLinq/Backsert.cs | 2 +- MoreLinq/CountDown.cs | 6 +- MoreLinq/CountMethods.cs | 4 +- MoreLinq/Delegating.cs | 2 + MoreLinq/EndsWith.cs | 6 +- MoreLinq/ExceptBy.cs | 6 +- MoreLinq/Experimental/Await.cs | 33 ++++---- MoreLinq/Experimental/TrySingle.cs | 2 +- MoreLinq/FallbackIfEmpty.cs | 2 +- MoreLinq/FillForward.cs | 2 +- MoreLinq/Flatten.cs | 4 +- MoreLinq/FullJoin.cs | 6 +- MoreLinq/GroupAdjacent.cs | 8 +- MoreLinq/Insert.cs | 4 +- MoreLinq/Interleave.cs | 8 +- MoreLinq/Lookup.cs | 2 + MoreLinq/MaxBy.cs | 8 +- MoreLinq/Move.cs | 2 +- MoreLinq/PadStart.cs | 42 ++++----- MoreLinq/PartialSort.cs | 2 +- MoreLinq/PendNode.cs | 4 +- MoreLinq/Permutations.cs | 2 +- MoreLinq/Random.cs | 7 +- MoreLinq/Reactive/Subject.cs | 2 +- MoreLinq/ReverseComparer.cs | 4 +- MoreLinq/RunLengthEncode.cs | 3 +- MoreLinq/Segment.cs | 4 +- MoreLinq/SequenceException.cs | 6 +- MoreLinq/SkipLast.cs | 14 ++- MoreLinq/StartsWith.cs | 4 +- MoreLinq/Subsets.cs | 2 +- MoreLinq/TakeLast.cs | 15 ++-- MoreLinq/ToArrayByIndex.cs | 4 +- MoreLinq/ToDataTable.cs | 4 +- MoreLinq/ToDelimitedString.cs | 5 +- MoreLinq/Trace.cs | 2 +- MoreLinq/Transpose.cs | 2 + bld/ExtensionsGenerator/Program.cs | 17 ++-- 131 files changed, 489 insertions(+), 496 deletions(-) diff --git a/.editorconfig b/.editorconfig index 91ca08d50..57e440765 100644 --- a/.editorconfig +++ b/.editorconfig @@ -26,28 +26,33 @@ indent_size = 4 max_line_length = 100 [*.cs] +dotnet_analyzer_diagnostic.category-Style.severity = warning + +# IDE0022: Use expression/block body for methods +dotnet_diagnostic.IDE0022.severity = suggestion + # Prefer "var" everywhere -csharp_style_var_for_built_in_types = true:suggestion -csharp_style_var_when_type_is_apparent = true:suggestion -csharp_style_var_elsewhere = true:suggestion +csharp_style_var_for_built_in_types = true +csharp_style_var_when_type_is_apparent = true +csharp_style_var_elsewhere = true # Prefer method-like constructs to have a block body -csharp_style_expression_bodied_methods = false:none -csharp_style_expression_bodied_constructors = false:none -csharp_style_expression_bodied_operators = false:none +csharp_style_expression_bodied_methods = true +csharp_style_expression_bodied_constructors = true +csharp_style_expression_bodied_operators = true # Prefer property-like constructs to have an expression-body -csharp_style_expression_bodied_properties = true:none -csharp_style_expression_bodied_indexers = true:none -csharp_style_expression_bodied_accessors = true:none +csharp_style_expression_bodied_properties = true +csharp_style_expression_bodied_indexers = true +csharp_style_expression_bodied_accessors = true # Suggest more modern language features when available -csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion -csharp_style_pattern_matching_over_as_with_null_check = true:suggestion -csharp_style_inlined_variable_declaration = true:suggestion -csharp_style_throw_expression = true:suggestion -csharp_style_conditional_delegate_call = true:suggestion -csharp_prefer_simple_default_expression = true:suggestion +csharp_style_pattern_matching_over_is_with_cast_check = true +csharp_style_pattern_matching_over_as_with_null_check = true +csharp_style_inlined_variable_declaration = true +csharp_style_throw_expression = true +csharp_style_conditional_delegate_call = true +csharp_prefer_simple_default_expression = true # Spacing csharp_space_after_cast = false @@ -58,6 +63,26 @@ csharp_space_between_method_declaration_parameter_list_parentheses = false csharp_preserve_single_line_statements = true csharp_preserve_single_line_blocks = true +# Indentation +csharp_indent_case_contents_when_block = false + # Modifier preferences dotnet_style_require_accessibility_modifiers = omit_if_default -dotnet_diagnostic.IDE0040.severity = warning + +# IDE0011: Add braces +csharp_prefer_braces = when_multiline + +# IDE0061: Use block body for local functions +csharp_style_expression_bodied_local_functions = true + +# IDE0065: Misplaced using directive +csharp_using_directive_placement = inside_namespace + +# IDE0048: Add parentheses for clarity +dotnet_diagnostic.IDE0048.severity = suggestion + +# IDE0055: Fix formatting +dotnet_diagnostic.IDE0055.severity = suggestion + +# IDE0046: Convert to conditional expression +dotnet_diagnostic.IDE0046.severity = suggestion diff --git a/MoreLinq.Test/.editorconfig b/MoreLinq.Test/.editorconfig index cc328a0d1..7132855c0 100644 --- a/MoreLinq.Test/.editorconfig +++ b/MoreLinq.Test/.editorconfig @@ -26,3 +26,11 @@ dotnet_diagnostic.CA1707.severity = none # CA1308: Normalize strings to uppercase dotnet_diagnostic.CA1308.severity = none + +# IDE0047: Remove unnecessary parentheses +dotnet_diagnostic.IDE0047.severity = suggestion + +[*{Test,Tests}.cs] + +# IDE0022: Use expression/block body for methods +dotnet_diagnostic.IDE0022.severity = none diff --git a/MoreLinq.Test/AcquireTest.cs b/MoreLinq.Test/AcquireTest.cs index 18050ed78..bdbbe2ec8 100644 --- a/MoreLinq.Test/AcquireTest.cs +++ b/MoreLinq.Test/AcquireTest.cs @@ -69,7 +69,7 @@ public void AcquireSome() sealed class Disposable : IDisposable { public bool Disposed { get; private set; } - public void Dispose() { Disposed = true; } + public void Dispose() => Disposed = true; } } } diff --git a/MoreLinq.Test/AggregateTest.cs b/MoreLinq.Test/AggregateTest.cs index d9cf0e6fb..9ef7b2336 100644 --- a/MoreLinq.Test/AggregateTest.cs +++ b/MoreLinq.Test/AggregateTest.cs @@ -112,9 +112,9 @@ public void SevenUniqueAccumulators() 0, (s, e) => s + e.Num, 0, (s, e) => e.Num % 2 == 0 ? s + e.Num : s, 0, (s, _) => s + 1, - (int?)null, (s, e) => s is {} n ? Math.Min(n, e.Num) : e.Num, - (int?)null, (s, e) => s is {} n ? Math.Max(n, e.Num) : e.Num, - new HashSet(), (s, e) => { s.Add(e.Str.Length); return s; }, + (int?)null, (s, e) => s is { } n ? Math.Min(n, e.Num) : e.Num, + (int?)null, (s, e) => s is { } n ? Math.Max(n, e.Num) : e.Num, + new HashSet(), (s, e) => { _ = s.Add(e.Str.Length); return s; }, new List<(int Num, string Str)>(), (s, e) => { s.Add((e.Num, e.Str)); return s; }, (sum, esum, count, min, max, lengths, items) => new { diff --git a/MoreLinq.Test/AppendTest.cs b/MoreLinq.Test/AppendTest.cs index 580a74875..736ba6498 100644 --- a/MoreLinq.Test/AppendTest.cs +++ b/MoreLinq.Test/AppendTest.cs @@ -54,7 +54,7 @@ public void AppendWithNullTail() [Test] public void AppendIsLazyInHeadSequence() { - new BreakingSequence().Append("tail"); + _ = new BreakingSequence().Append("tail"); } #endregion @@ -81,7 +81,7 @@ into e [Test] public void AppendWithSharedSource() { - var first = new [] { 1 }.Append(2); + var first = new[] { 1 }.Append(2); var second = first.Append(3).Append(4); var third = first.Append(4).Append(8); diff --git a/MoreLinq.Test/AssertCountTest.cs b/MoreLinq.Test/AssertCountTest.cs index 2a6e5ddf3..73aee530f 100644 --- a/MoreLinq.Test/AssertCountTest.cs +++ b/MoreLinq.Test/AssertCountTest.cs @@ -104,13 +104,13 @@ public TestException(int cmp, int count) [Test] public void AssertCountIsLazy() { - new BreakingSequence().AssertCount(0); + _ = new BreakingSequence().AssertCount(0); } [Test] public void AssertCountWithCollectionIsLazy() { - new BreakingCollection(new int[5]).AssertCount(0); + _ = new BreakingCollection(new int[5]).AssertCount(0); } [Test] @@ -133,7 +133,7 @@ public void AssertCountWithMismatchingCollectionCount(int sourceCount, int count [Test] public void AssertCountWithReadOnlyCollectionIsLazy() { - new BreakingReadOnlyCollection(5).AssertCount(0); + _ = new BreakingReadOnlyCollection(5).AssertCount(0); } } } diff --git a/MoreLinq.Test/AssertTest.cs b/MoreLinq.Test/AssertTest.cs index 553701ff2..ecd288ce6 100644 --- a/MoreLinq.Test/AssertTest.cs +++ b/MoreLinq.Test/AssertTest.cs @@ -26,14 +26,14 @@ public class AssertTest [Test] public void AssertIsLazy() { - new BreakingSequence().Assert(BreakingFunc.Of()); - new BreakingSequence().Assert(BreakingFunc.Of(), BreakingFunc.Of()); + _ = new BreakingSequence().Assert(BreakingFunc.Of()); + _ = new BreakingSequence().Assert(BreakingFunc.Of(), BreakingFunc.Of()); } [Test] public void AssertSequenceWithValidAllElements() { - var source = new[] {2, 4, 6, 8}; + var source = new[] { 2, 4, 6, 8 }; source.Assert(n => n % 2 == 0).AssertSequenceEqual(source); } @@ -66,7 +66,7 @@ public void AssertSequenceWithInvalidElementsAndCustomError() sealed class ValueException : Exception { public object Value { get; } - public ValueException(object value) { Value = value; } + public ValueException(object value) => Value = value; } } } diff --git a/MoreLinq.Test/Async/AsyncEnumerable.cs b/MoreLinq.Test/Async/AsyncEnumerable.cs index 9e34f492a..dc9d3649c 100644 --- a/MoreLinq.Test/Async/AsyncEnumerable.cs +++ b/MoreLinq.Test/Async/AsyncEnumerable.cs @@ -511,19 +511,19 @@ public static ValueTask ToArrayAsync(this IAsyncEnumerable> ToDictionaryAsync(this IAsyncEnumerable source, Func keySelector) - where TKey: notnull => + where TKey : notnull => LinqEnumerable.ToDictionaryAsync(source, keySelector); public static ValueTask> ToDictionaryAsync(this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) - where TKey: notnull => + where TKey : notnull => LinqEnumerable.ToDictionaryAsync(source, keySelector, comparer); public static ValueTask> ToDictionaryAsync(this IAsyncEnumerable source, Func keySelector, Func elementSelector) - where TKey: notnull => + where TKey : notnull => LinqEnumerable.ToDictionaryAsync(source, keySelector, elementSelector); public static ValueTask> ToDictionaryAsync(this IAsyncEnumerable source, Func keySelector, Func elementSelector, IEqualityComparer comparer) - where TKey: notnull => + where TKey : notnull => LinqEnumerable.ToDictionaryAsync(source, keySelector, elementSelector, comparer); public static ValueTask> ToListAsync(this IAsyncEnumerable source) => diff --git a/MoreLinq.Test/BacksertTest.cs b/MoreLinq.Test/BacksertTest.cs index a26e6ac8f..dbc985903 100644 --- a/MoreLinq.Test/BacksertTest.cs +++ b/MoreLinq.Test/BacksertTest.cs @@ -26,7 +26,7 @@ public class BacksertTest [Test] public void BacksertIsLazy() { - new BreakingSequence().Backsert(new BreakingSequence(), 0); + _ = new BreakingSequence().Backsert(new BreakingSequence(), 0); } [Test] diff --git a/MoreLinq.Test/BatchTest.cs b/MoreLinq.Test/BatchTest.cs index e2b46ac65..ca71e9938 100644 --- a/MoreLinq.Test/BatchTest.cs +++ b/MoreLinq.Test/BatchTest.cs @@ -92,7 +92,7 @@ public void BatchSequencesAreIndependentInstances() [Test] public void BatchIsLazy() { - new BreakingSequence().Batch(1); + _ = new BreakingSequence().Batch(1); } [TestCase(SourceKind.BreakingCollection , 0)] diff --git a/MoreLinq.Test/BreakingCollection.cs b/MoreLinq.Test/BreakingCollection.cs index 7cb34e6b9..6cb4d03ed 100644 --- a/MoreLinq.Test/BreakingCollection.cs +++ b/MoreLinq.Test/BreakingCollection.cs @@ -24,7 +24,7 @@ class BreakingCollection : BreakingSequence, ICollection { protected readonly IList List; - public BreakingCollection(params T[] values) : this ((IList) values) {} + public BreakingCollection(params T[] values) : this((IList)values) { } public BreakingCollection(IList list) => List = list; public int Count => List.Count; diff --git a/MoreLinq.Test/BreakingList.cs b/MoreLinq.Test/BreakingList.cs index e2cb32936..5f054aba2 100644 --- a/MoreLinq.Test/BreakingList.cs +++ b/MoreLinq.Test/BreakingList.cs @@ -30,8 +30,8 @@ namespace MoreLinq.Test sealed class BreakingList : BreakingCollection, IList { - public BreakingList() : this(new List()) {} - public BreakingList(List list) : base(list) {} + public BreakingList() : this(new List()) { } + public BreakingList(List list) : base(list) { } public int IndexOf(T item) => List.IndexOf(item); public void Insert(int index, T item) => throw new NotImplementedException(); diff --git a/MoreLinq.Test/BreakingReadOnlyCollection.cs b/MoreLinq.Test/BreakingReadOnlyCollection.cs index 5a13ed7b6..9748e77ba 100644 --- a/MoreLinq.Test/BreakingReadOnlyCollection.cs +++ b/MoreLinq.Test/BreakingReadOnlyCollection.cs @@ -23,7 +23,7 @@ class BreakingReadOnlyCollection : BreakingSequence, IReadOnlyCollection _collection; - public BreakingReadOnlyCollection(params T[] values) : this ((IReadOnlyCollection) values) {} + public BreakingReadOnlyCollection(params T[] values) : this((IReadOnlyCollection)values) { } public BreakingReadOnlyCollection(IReadOnlyCollection collection) => _collection = collection; public int Count => _collection.Count; } diff --git a/MoreLinq.Test/BreakingReadOnlyList.cs b/MoreLinq.Test/BreakingReadOnlyList.cs index 5fb25c193..0e368c8aa 100644 --- a/MoreLinq.Test/BreakingReadOnlyList.cs +++ b/MoreLinq.Test/BreakingReadOnlyList.cs @@ -31,8 +31,8 @@ sealed class BreakingReadOnlyList : BreakingReadOnlyCollection, IReadOnlyL { readonly IReadOnlyList _list; - public BreakingReadOnlyList(params T[] values) : this ((IReadOnlyList) values) {} - public BreakingReadOnlyList(IReadOnlyList list) : base (list) + public BreakingReadOnlyList(params T[] values) : this((IReadOnlyList)values) { } + public BreakingReadOnlyList(IReadOnlyList list) : base(list) => _list = list; public T this[int index] => _list[index]; diff --git a/MoreLinq.Test/CartesianTest.cs b/MoreLinq.Test/CartesianTest.cs index 4277eb7bf..2e890ba63 100644 --- a/MoreLinq.Test/CartesianTest.cs +++ b/MoreLinq.Test/CartesianTest.cs @@ -31,9 +31,8 @@ public class CartesianTests [Test] public void TestCartesianIsLazy() { - new BreakingSequence() - .Cartesian(new BreakingSequence(), - BreakingFunc.Of()); + var bs = new BreakingSequence(); + _ = bs.Cartesian(new BreakingSequence(), BreakingFunc.Of()); } /// @@ -82,7 +81,7 @@ public void TestCartesianProductCount() { const int countA = 100; const int countB = 75; - const int expectedCount = countA*countB; + const int expectedCount = countA * countB; using var sequenceA = Enumerable.Range(1, countA).AsTestingSequence(); using var sequenceB = Enumerable.Range(1, countB).AsTestingSequence(); diff --git a/MoreLinq.Test/ChooseTest.cs b/MoreLinq.Test/ChooseTest.cs index 138b565c4..a2ebefc40 100644 --- a/MoreLinq.Test/ChooseTest.cs +++ b/MoreLinq.Test/ChooseTest.cs @@ -26,8 +26,7 @@ public class ChooseTest [Test] public void IsLazy() { - new BreakingSequence() - .Choose(BreakingFunc.Of()); + _ = new BreakingSequence().Choose(BreakingFunc.Of()); } [Test] @@ -76,7 +75,7 @@ static class Option public void ThoseThatAreIntegers() { new int?[] { 0, 1, 2, null, 4, null, 6, null, null, 9 } - .Choose(e => e is {} n ? Option.Some(n) : Option.None) + .Choose(e => e is { } n ? Option.Some(n) : Option.None) .AssertSequenceEqual(0, 1, 2, 4, 6, 9); } diff --git a/MoreLinq.Test/CountByTest.cs b/MoreLinq.Test/CountByTest.cs index f0732a7ba..fa5cb369e 100644 --- a/MoreLinq.Test/CountByTest.cs +++ b/MoreLinq.Test/CountByTest.cs @@ -85,7 +85,7 @@ public void CountByHasKeysOrderedLikeGroupBy() [Test] public void CountByIsLazy() { - new BreakingSequence().CountBy(BreakingFunc.Of()); + _ = new BreakingSequence().CountBy(BreakingFunc.Of()); } [Test] diff --git a/MoreLinq.Test/CountDownTest.cs b/MoreLinq.Test/CountDownTest.cs index a28153d33..5d047e177 100644 --- a/MoreLinq.Test/CountDownTest.cs +++ b/MoreLinq.Test/CountDownTest.cs @@ -28,8 +28,8 @@ public class CountDownTest [Test] public void IsLazy() { - new BreakingSequence() - .CountDown(42, BreakingFunc.Of()); + var bs = new BreakingSequence(); + _ = bs.CountDown(42, BreakingFunc.Of()); } [Test] @@ -38,7 +38,7 @@ public void WithNegativeCount() const int count = 10; Enumerable.Range(1, count) .CountDown(-1000, (_, cd) => cd) - .AssertSequenceEqual(Enumerable.Repeat((int?) null, count)); + .AssertSequenceEqual(Enumerable.Repeat((int?)null, count)); } static IEnumerable GetData(Func selector) diff --git a/MoreLinq.Test/CurrentThreadCultureScope.cs b/MoreLinq.Test/CurrentThreadCultureScope.cs index e647a2822..7f028c787 100644 --- a/MoreLinq.Test/CurrentThreadCultureScope.cs +++ b/MoreLinq.Test/CurrentThreadCultureScope.cs @@ -22,19 +22,9 @@ namespace MoreLinq.Test sealed class CurrentThreadCultureScope : Scope { public CurrentThreadCultureScope(CultureInfo @new) : - base(CultureInfo.CurrentCulture) - { - Install(@new); - } + base(CultureInfo.CurrentCulture) => Install(@new); - protected override void Restore(CultureInfo old) - { - Install(old); - } - - static void Install(CultureInfo value) - { - CultureInfo.CurrentCulture = value; - } + protected override void Restore(CultureInfo old) => Install(old); + static void Install(CultureInfo value) => CultureInfo.CurrentCulture = value; } } diff --git a/MoreLinq.Test/DistinctByTest.cs b/MoreLinq.Test/DistinctByTest.cs index 91dbf8c94..7035578f2 100644 --- a/MoreLinq.Test/DistinctByTest.cs +++ b/MoreLinq.Test/DistinctByTest.cs @@ -34,7 +34,7 @@ public void DistinctBy() [Test] public void DistinctByIsLazy() { - new BreakingSequence().DistinctBy(BreakingFunc.Of()); + _ = new BreakingSequence().DistinctBy(BreakingFunc.Of()); } [Test] @@ -56,8 +56,8 @@ public void DistinctByNullComparer() [Test] public void DistinctByIsLazyWithComparer() { - new BreakingSequence() - .DistinctBy(BreakingFunc.Of(), StringComparer.Ordinal); + var bs = new BreakingSequence(); + _ = bs.DistinctBy(BreakingFunc.Of(), StringComparer.Ordinal); } } } diff --git a/MoreLinq.Test/EndsWithTest.cs b/MoreLinq.Test/EndsWithTest.cs index 316dc7271..108980360 100644 --- a/MoreLinq.Test/EndsWithTest.cs +++ b/MoreLinq.Test/EndsWithTest.cs @@ -24,17 +24,17 @@ namespace MoreLinq.Test [TestFixture] public class EndsWithTest { - [TestCase(new[] {1, 2, 3}, new[] {2, 3}, ExpectedResult = true)] - [TestCase(new[] {1, 2, 3}, new[] {1, 2, 3}, ExpectedResult = true)] - [TestCase(new[] {1, 2, 3}, new[] {0, 1, 2, 3}, ExpectedResult = false)] + [TestCase(new[] { 1, 2, 3 }, new[] { 2, 3 }, ExpectedResult = true)] + [TestCase(new[] { 1, 2, 3 }, new[] { 1, 2, 3 }, ExpectedResult = true)] + [TestCase(new[] { 1, 2, 3 }, new[] { 0, 1, 2, 3 }, ExpectedResult = false)] public bool EndsWithWithIntegers(IEnumerable first, IEnumerable second) { return first.EndsWith(second); } - [TestCase(new[] {'1', '2', '3'}, new[] {'2', '3'}, ExpectedResult = true)] - [TestCase(new[] {'1', '2', '3'}, new[] {'1', '2', '3'}, ExpectedResult = true)] - [TestCase(new[] {'1', '2', '3'}, new[] {'0', '1', '2', '3'}, ExpectedResult = false)] + [TestCase(new[] { '1', '2', '3' }, new[] { '2', '3' }, ExpectedResult = true)] + [TestCase(new[] { '1', '2', '3' }, new[] { '1', '2', '3' }, ExpectedResult = true)] + [TestCase(new[] { '1', '2', '3' }, new[] { '0', '1', '2', '3' }, ExpectedResult = false)] public bool EndsWithWithChars(IEnumerable first, IEnumerable second) { return first.EndsWith(second); @@ -58,7 +58,7 @@ public void EndsWithReturnsTrueIfBothEmpty() [Test] public void EndsWithReturnsFalseIfOnlyFirstIsEmpty() { - Assert.That(new int[0].EndsWith(new[] {1,2,3}), Is.False); + Assert.That(new int[0].EndsWith(new[] { 1, 2, 3 }), Is.False); } [TestCase("", "", ExpectedResult = true)] @@ -72,18 +72,18 @@ public bool EndsWithReturnsTrueIfSecondIsEmpty(string first, string second) [Test] public void EndsWithDisposesBothSequenceEnumerators() { - using var first = TestingSequence.Of(1,2,3); + using var first = TestingSequence.Of(1, 2, 3); using var second = TestingSequence.Of(1); - first.EndsWith(second); + _ = first.EndsWith(second); } [Test] [SuppressMessage("ReSharper", "RedundantArgumentDefaultValue")] public void EndsWithUsesSpecifiedEqualityComparerOrDefault() { - var first = new[] {1,2,3}; - var second = new[] {4,5,6}; + var first = new[] { 1, 2, 3 }; + var second = new[] { 4, 5, 6 }; Assert.That(first.EndsWith(second), Is.False); Assert.That(first.EndsWith(second, null), Is.False); diff --git a/MoreLinq.Test/EqualityComparer.cs b/MoreLinq.Test/EqualityComparer.cs index 655999130..4e3a4e8a9 100644 --- a/MoreLinq.Test/EqualityComparer.cs +++ b/MoreLinq.Test/EqualityComparer.cs @@ -36,7 +36,7 @@ sealed class DelegatingComparer : IEqualityComparer readonly Func _hasher; public DelegatingComparer(Func comparer) - : this(comparer, x => x == null ? 0 : x.GetHashCode()) {} + : this(comparer, x => x == null ? 0 : x.GetHashCode()) { } DelegatingComparer(Func comparer, Func hasher) { diff --git a/MoreLinq.Test/EquiZipTest.cs b/MoreLinq.Test/EquiZipTest.cs index 477a86384..523d29ad0 100644 --- a/MoreLinq.Test/EquiZipTest.cs +++ b/MoreLinq.Test/EquiZipTest.cs @@ -73,7 +73,7 @@ public void ZipWithFirstSequnceLongerThanSecondFailStrategy() public void ZipIsLazy() { var bs = new BreakingSequence(); - bs.EquiZip(bs, BreakingFunc.Of()); + _ = bs.EquiZip(bs, BreakingFunc.Of()); } [Test] diff --git a/MoreLinq.Test/EvaluateTest.cs b/MoreLinq.Test/EvaluateTest.cs index 40bd4eaab..2e02e932e 100644 --- a/MoreLinq.Test/EvaluateTest.cs +++ b/MoreLinq.Test/EvaluateTest.cs @@ -25,7 +25,7 @@ public class EvaluateTest [Test] public void TestEvaluateIsLazy() { - new BreakingSequence>().Evaluate(); + _ = new BreakingSequence>().Evaluate(); } [Test] diff --git a/MoreLinq.Test/ExceptByTest.cs b/MoreLinq.Test/ExceptByTest.cs index a72aee232..43c3fa1a1 100644 --- a/MoreLinq.Test/ExceptByTest.cs +++ b/MoreLinq.Test/ExceptByTest.cs @@ -36,7 +36,7 @@ public void SimpleExceptBy() public void ExceptByIsLazy() { var bs = new BreakingSequence(); - bs.ExceptBy(bs, BreakingFunc.Of()); + _ = bs.ExceptBy(bs, BreakingFunc.Of()); } [Test] @@ -52,7 +52,7 @@ public void ExceptByDoesNotRepeatSourceElementsWithDuplicateKeys() public void ExceptByWithComparer() { string[] first = { "first", "second", "third", "fourth" }; - string[] second = { "FIRST" , "thiRD", "FIFTH" }; + string[] second = { "FIRST", "thiRD", "FIFTH" }; var result = first.ExceptBy(second, word => word, StringComparer.OrdinalIgnoreCase); result.AssertSequenceEqual("second", "fourth"); } @@ -70,7 +70,7 @@ public void ExceptByNullComparer() public void ExceptByIsLazyWithComparer() { var bs = new BreakingSequence(); - bs.ExceptBy(bs, BreakingFunc.Of(), StringComparer.Ordinal); + _ = bs.ExceptBy(bs, BreakingFunc.Of(), StringComparer.Ordinal); } } } diff --git a/MoreLinq.Test/ExcludeTest.cs b/MoreLinq.Test/ExcludeTest.cs index ff87a8545..faf31f5dc 100644 --- a/MoreLinq.Test/ExcludeTest.cs +++ b/MoreLinq.Test/ExcludeTest.cs @@ -31,7 +31,7 @@ public class ExcludeTests [Test] public void TestExcludeIsLazy() { - new BreakingSequence().Exclude(0, 10); + _ = new BreakingSequence().Exclude(0, 10); } /// diff --git a/MoreLinq.Test/FillBackwardTest.cs b/MoreLinq.Test/FillBackwardTest.cs index 19129b27b..34869b06d 100644 --- a/MoreLinq.Test/FillBackwardTest.cs +++ b/MoreLinq.Test/FillBackwardTest.cs @@ -25,7 +25,7 @@ public class FillBackwardTest [Test] public void FillBackwardIsLazy() { - new BreakingSequence().FillBackward(); + _ = new BreakingSequence().FillBackward(); } [Test] diff --git a/MoreLinq.Test/FillForwardTest.cs b/MoreLinq.Test/FillForwardTest.cs index c881210e9..bd156f096 100644 --- a/MoreLinq.Test/FillForwardTest.cs +++ b/MoreLinq.Test/FillForwardTest.cs @@ -27,7 +27,7 @@ public class FillForwardTest [Test] public void FillForwardIsLazy() { - new BreakingSequence().FillForward(); + _ = new BreakingSequence().FillForward(); } [Test] diff --git a/MoreLinq.Test/FlattenTest.cs b/MoreLinq.Test/FlattenTest.cs index d9bf5a89d..f08a8f6fb 100644 --- a/MoreLinq.Test/FlattenTest.cs +++ b/MoreLinq.Test/FlattenTest.cs @@ -109,7 +109,7 @@ public void FlattenCast() [Test] public void FlattenIsLazy() { - new BreakingSequence().Flatten(); + _ = new BreakingSequence().Flatten(); } // Flatten(this IEnumerable source, Func predicate) @@ -220,7 +220,7 @@ public void FlattenPredicateAlwaysTrue() [Test] public void FlattenPredicateIsLazy() { - new BreakingSequence().Flatten(BreakingFunc.Of()); + _ = new BreakingSequence().Flatten(BreakingFunc.Of()); } [Test] @@ -298,7 +298,7 @@ public void FlattenEvaluatesInnerSequencesLazily() [Test] public void FlattenSelectorIsLazy() { - new BreakingSequence().Flatten(BreakingFunc.Of()); + _ = new BreakingSequence().Flatten(BreakingFunc.Of()); } [Test] @@ -422,7 +422,7 @@ sealed class Tree public readonly Tree? Left; public readonly Tree? Right; - public Tree(T value) : this(null, value, null) {} + public Tree(T value) : this(null, value, null) { } public Tree(Tree? left, T value, Tree? right) { Left = left; diff --git a/MoreLinq.Test/FromTest.cs b/MoreLinq.Test/FromTest.cs index 2822011f0..272c5cf77 100644 --- a/MoreLinq.Test/FromTest.cs +++ b/MoreLinq.Test/FromTest.cs @@ -26,10 +26,10 @@ public class FromTest public void TestFromIsLazy() { var breakingFunc = BreakingFunc.Of(); - MoreEnumerable.From(breakingFunc); - MoreEnumerable.From(breakingFunc, breakingFunc); - MoreEnumerable.From(breakingFunc, breakingFunc, breakingFunc); - MoreEnumerable.From(breakingFunc, breakingFunc, breakingFunc, breakingFunc); + _ = MoreEnumerable.From(breakingFunc); + _ = MoreEnumerable.From(breakingFunc, breakingFunc); + _ = MoreEnumerable.From(breakingFunc, breakingFunc, breakingFunc); + _ = MoreEnumerable.From(breakingFunc, breakingFunc, breakingFunc, breakingFunc); } [TestCase(1)] @@ -59,7 +59,7 @@ public void TestFromInvokesMethods(int numArgs) [TestCase(4)] public void TestFromInvokesMethodsMultipleTimes(int numArgs) { - var evals = new [] { 0, 0, 0, 0 }; + var evals = new[] { 0, 0, 0, 0 }; int F1() { evals[0]++; return -2; } int F2() { evals[1]++; return -2; } int F3() { evals[2]++; return -2; } diff --git a/MoreLinq.Test/FullGroupJoinTest.cs b/MoreLinq.Test/FullGroupJoinTest.cs index f5435cfa5..fcb18430d 100644 --- a/MoreLinq.Test/FullGroupJoinTest.cs +++ b/MoreLinq.Test/FullGroupJoinTest.cs @@ -34,7 +34,7 @@ public void FullGroupIsLazy() var bf = BreakingFunc.Of(); var bfg = BreakingFunc.Of, IEnumerable, int>(); - bs.FullGroupJoin(bs, bf, bf, bfg); + _ = bs.FullGroupJoin(bs, bf, bf, bfg); } [TestCase(CustomResult)] diff --git a/MoreLinq.Test/GenerateTest.cs b/MoreLinq.Test/GenerateTest.cs index a9e60a8bb..d5688311e 100644 --- a/MoreLinq.Test/GenerateTest.cs +++ b/MoreLinq.Test/GenerateTest.cs @@ -41,7 +41,7 @@ public void GenerateProcessesNonNumerics() [Test] public void GenerateIsLazy() { - MoreEnumerable.Generate(0, BreakingFunc.Of()); + _ = MoreEnumerable.Generate(0, BreakingFunc.Of()); } [Test] @@ -55,7 +55,7 @@ public void GenerateFuncIsNotInvokedUnnecessarily() [Test] public void GenerateByIndexIsLazy() { - MoreEnumerable.GenerateByIndex(BreakingFunc.Of()); + _ = MoreEnumerable.GenerateByIndex(BreakingFunc.Of()); } [Test] diff --git a/MoreLinq.Test/GroupAdjacentTest.cs b/MoreLinq.Test/GroupAdjacentTest.cs index dbc1e8762..d6da9909a 100644 --- a/MoreLinq.Test/GroupAdjacentTest.cs +++ b/MoreLinq.Test/GroupAdjacentTest.cs @@ -32,12 +32,12 @@ public void GroupAdjacentIsLazy() var bfo = BreakingFunc.Of(); var bfg = BreakingFunc.Of, IEnumerable>(); - bs.GroupAdjacent(bf); - bs.GroupAdjacent(bf, bfo); - bs.GroupAdjacent(bf, bfo, EqualityComparer.Default); - bs.GroupAdjacent(bf, EqualityComparer.Default); - bs.GroupAdjacent(bf, bfg); - bs.GroupAdjacent(bf, bfg, EqualityComparer.Default); + _ = bs.GroupAdjacent(bf); + _ = bs.GroupAdjacent(bf, bfo); + _ = bs.GroupAdjacent(bf, bfo, EqualityComparer.Default); + _ = bs.GroupAdjacent(bf, EqualityComparer.Default); + _ = bs.GroupAdjacent(bf, bfg); + _ = bs.GroupAdjacent(bf, bfg, EqualityComparer.Default); } [Test] diff --git a/MoreLinq.Test/IndexByTest.cs b/MoreLinq.Test/IndexByTest.cs index 8b71ea268..a220939f8 100644 --- a/MoreLinq.Test/IndexByTest.cs +++ b/MoreLinq.Test/IndexByTest.cs @@ -72,7 +72,7 @@ public void IndexByWithEqualityComparer() [Test] public void IndexByIsLazy() { - new BreakingSequence().IndexBy(BreakingFunc.Of()); + _ = new BreakingSequence().IndexBy(BreakingFunc.Of()); } [Test] diff --git a/MoreLinq.Test/IndexTest.cs b/MoreLinq.Test/IndexTest.cs index 6b57ee2c3..5956f8b38 100644 --- a/MoreLinq.Test/IndexTest.cs +++ b/MoreLinq.Test/IndexTest.cs @@ -26,8 +26,8 @@ public class IndexTest public void IndexIsLazy() { var bs = new BreakingSequence(); - bs.Index(); - bs.Index(0); + _ = bs.Index(); + _ = bs.Index(0); } [Test] diff --git a/MoreLinq.Test/InsertTest.cs b/MoreLinq.Test/InsertTest.cs index 7f9af900f..1dd148bd0 100644 --- a/MoreLinq.Test/InsertTest.cs +++ b/MoreLinq.Test/InsertTest.cs @@ -83,7 +83,7 @@ public void Insert(int count, int index) [Test] public void InsertIsLazy() { - new BreakingSequence().Insert(new BreakingSequence(), 0); + _ = new BreakingSequence().Insert(new BreakingSequence(), 0); } } } diff --git a/MoreLinq.Test/InterleaveTest.cs b/MoreLinq.Test/InterleaveTest.cs index 945dc975f..84db32566 100644 --- a/MoreLinq.Test/InterleaveTest.cs +++ b/MoreLinq.Test/InterleaveTest.cs @@ -32,7 +32,7 @@ public class InterleaveTests [Test] public void TestInterleaveIsLazy() { - new BreakingSequence().Interleave(new BreakingSequence()); + _ = new BreakingSequence().Interleave(new BreakingSequence()); } /// diff --git a/MoreLinq.Test/LagTest.cs b/MoreLinq.Test/LagTest.cs index 3a1c0fdfd..fad1b192c 100644 --- a/MoreLinq.Test/LagTest.cs +++ b/MoreLinq.Test/LagTest.cs @@ -31,8 +31,8 @@ public class LagTests [Test] public void TestLagIsLazy() { - new BreakingSequence().Lag(5, BreakingFunc.Of()); - new BreakingSequence().Lag(5, -1, BreakingFunc.Of()); + _ = new BreakingSequence().Lag(5, BreakingFunc.Of()); + _ = new BreakingSequence().Lag(5, -1, BreakingFunc.Of()); } /// diff --git a/MoreLinq.Test/LeadTest.cs b/MoreLinq.Test/LeadTest.cs index 8b2e245b8..36a4197e2 100644 --- a/MoreLinq.Test/LeadTest.cs +++ b/MoreLinq.Test/LeadTest.cs @@ -31,8 +31,8 @@ public class LeadTests [Test] public void TestLeadIsLazy() { - new BreakingSequence().Lead(5, BreakingFunc.Of()); - new BreakingSequence().Lead(5, -1, BreakingFunc.Of()); + _ = new BreakingSequence().Lead(5, BreakingFunc.Of()); + _ = new BreakingSequence().Lead(5, -1, BreakingFunc.Of()); } /// diff --git a/MoreLinq.Test/MaxByTest.cs b/MoreLinq.Test/MaxByTest.cs index 0abc1beb6..6934c6773 100644 --- a/MoreLinq.Test/MaxByTest.cs +++ b/MoreLinq.Test/MaxByTest.cs @@ -25,7 +25,7 @@ public class MaxByTest [Test] public void MaxByIsLazy() { - new BreakingSequence().MaxBy(BreakingFunc.Of()); + _ = new BreakingSequence().MaxBy(BreakingFunc.Of()); } [Test] diff --git a/MoreLinq.Test/MemoizeTest.cs b/MoreLinq.Test/MemoizeTest.cs index 6cc0b6565..f2bed5c5e 100644 --- a/MoreLinq.Test/MemoizeTest.cs +++ b/MoreLinq.Test/MemoizeTest.cs @@ -101,7 +101,7 @@ public void MemoizeWithPartialIterationBeforeCompleteIteration() [Test] public void MemoizeIsLazy() { - new BreakingSequence().Memoize(); + _ = new BreakingSequence().Memoize(); } [TestCase(SourceKind.BreakingCollection)] @@ -148,7 +148,7 @@ public void MemoizeWithDisposeOnEarlyExitTrue() var memoized = xs.Memoize(); - using ((IDisposable) memoized) + using ((IDisposable)memoized) memoized.Take(1).Consume(); } @@ -204,7 +204,7 @@ IEnumerable TestSequence() void Run() { - using ((IDisposable) memoized) + using ((IDisposable)memoized) memoized.Take(1).Consume(); } @@ -219,7 +219,7 @@ public static void MemoizeIteratorThrowsWhenCacheDisposedDuringIteration() { var sequence = Enumerable.Range(1, 10); var memoized = sequence.Memoize(); - var disposable = (IDisposable) memoized; + var disposable = (IDisposable)memoized; using var reader = memoized.Read(); Assert.That(reader.Read(), Is.EqualTo(1)); @@ -306,7 +306,7 @@ public void MemoizeRethrowsErrorDuringFirstIterationStartToAllIterationsUntilDis for (var i = 0; i < 2; i++) Assert.That(memo.First, Throws.TypeOf().And.SameAs(error)); - ((IDisposable) memo).Dispose(); + ((IDisposable)memo).Dispose(); Assert.That(memo.Single(), Is.EqualTo(obj)); } } diff --git a/MoreLinq.Test/MinByTest.cs b/MoreLinq.Test/MinByTest.cs index 49c8565a7..a549f1387 100644 --- a/MoreLinq.Test/MinByTest.cs +++ b/MoreLinq.Test/MinByTest.cs @@ -25,7 +25,7 @@ public class MinByTest [Test] public void MinByIsLazy() { - new BreakingSequence().MinBy(BreakingFunc.Of()); + _ = new BreakingSequence().MinBy(BreakingFunc.Of()); } [Test] diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index da095895b..198a6756e 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -5,12 +5,10 @@ net7.0;net6.0;netcoreapp3.1;net462 portable MoreLinq.Test - Exe + Exe true false - library - MoreLinq.Test.Program 618 @@ -50,6 +48,7 @@ + diff --git a/MoreLinq.Test/MoveTest.cs b/MoreLinq.Test/MoveTest.cs index abe85b2ef..67973459f 100644 --- a/MoreLinq.Test/MoveTest.cs +++ b/MoreLinq.Test/MoveTest.cs @@ -48,7 +48,7 @@ public void MoveWithNegativeToIndex() [Test] public void MoveIsLazy() { - new BreakingSequence().Move(0, 0, 0); + _ = new BreakingSequence().Move(0, 0, 0); } [TestCaseSource(nameof(MoveSource))] diff --git a/MoreLinq.Test/NullArgumentTest.cs b/MoreLinq.Test/NullArgumentTest.cs index 773bdd6b4..a11d355ac 100644 --- a/MoreLinq.Test/NullArgumentTest.cs +++ b/MoreLinq.Test/NullArgumentTest.cs @@ -71,7 +71,7 @@ static IEnumerable GetCanBeNullTestCases() => GetTestCases(canBeNull: true, testCaseFactory: (method, args, _) => () => method.Invoke(null, args)); static IEnumerable GetTestCases(bool canBeNull, Func testCaseFactory) => - from m in typeof (MoreEnumerable).GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly) + from m in typeof(MoreEnumerable).GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly) from t in CreateTestCases(m, canBeNull, testCaseFactory) select t; @@ -81,14 +81,14 @@ static IEnumerable CreateTestCases(MethodInfo methodDefinition, b var parameters = method.GetParameters().ToList(); return from param in parameters - where IsReferenceType(param) && CanBeNull(param) == canBeNull - let arguments = parameters.Select(p => p == param ? null : CreateInstance(p.ParameterType)).ToArray() - let testCase = testCaseFactory(method, arguments, + where IsReferenceType(param) && CanBeNull(param) == canBeNull + let arguments = parameters.Select(p => p == param ? null : CreateInstance(p.ParameterType)).ToArray() + let testCase = testCaseFactory(method, arguments, #pragma warning disable CA2201 // Do not raise reserved exception types - param.Name ?? throw new NullReferenceException()) + param.Name ?? throw new NullReferenceException()) #pragma warning restore CA2201 // Do not raise reserved exception types - let testName = GetTestName(methodDefinition, param) - select (ITestCaseData) new TestCaseData(testCase).SetName(testName); + let testName = GetTestName(methodDefinition, param) + select (ITestCaseData)new TestCaseData(testCase).SetName(testName); } static string GetTestName(MethodInfo definition, ParameterInfo parameter) => @@ -120,7 +120,7 @@ static bool IsReferenceType(ParameterInfo parameter) => static bool CanBeNull(ParameterInfo parameter) { var nullableTypes = - from t in new[] { typeof (IEqualityComparer<>), typeof (IComparer<>) } + from t in new[] { typeof(IEqualityComparer<>), typeof(IComparer<>) } select t.GetTypeInfo(); var nullableParameters = new[] @@ -143,8 +143,8 @@ static bool CanBeNull(ParameterInfo parameter) static object CreateInstance(Type type) { - if (type == typeof (int)) return 7; // int is used as size/length/range etc. avoid ArgumentOutOfRange for '0'. - if (type == typeof (string)) return ""; + if (type == typeof(int)) return 7; // int is used as size/length/range etc. avoid ArgumentOutOfRange for '0'. + if (type == typeof(string)) return ""; if (type == typeof(TaskScheduler)) return TaskScheduler.Default; if (type == typeof(IEnumerable)) return new[] { 1, 2, 3 }; // Provide non-empty sequence for MinBy/MaxBy. if (typeof(Delegate).IsAssignableFrom(type)) return CreateDelegateInstance(type); @@ -184,8 +184,8 @@ static Delegate CreateDelegateInstance(Type type) static object CreateGenericInterfaceInstance(TypeInfo type) { Debug.Assert(type.IsGenericType && type.IsInterface); - var name = type.Name.Substring(1); // Delete first character, i.e. the 'I' in IEnumerable - var definition = typeof (GenericArgs).GetTypeInfo().GetNestedType(name); + var name = type.Name[1..]; // Delete first character, i.e. the 'I' in IEnumerable + var definition = typeof(GenericArgs).GetTypeInfo().GetNestedType(name); Debug.Assert(definition is not null); var instance = Activator.CreateInstance(definition.MakeGenericType(type.GetGenericArguments())); Debug.Assert(instance is not null); diff --git a/MoreLinq.Test/PadStartTest.cs b/MoreLinq.Test/PadStartTest.cs index a65e3bd2b..7e504f5f4 100644 --- a/MoreLinq.Test/PadStartTest.cs +++ b/MoreLinq.Test/PadStartTest.cs @@ -35,7 +35,7 @@ public void PadStartWithNegativeWidth() [Test] public void PadStartIsLazy() { - new BreakingSequence().PadStart(0); + _ = new BreakingSequence().PadStart(0); } public class PadStartWithDefaultPadding @@ -70,7 +70,7 @@ public void PadStartWithPaddingWithNegativeWidth() [Test] public void PadStartWithPaddingIsLazy() { - new BreakingSequence().PadStart(0, -1); + _ = new BreakingSequence().PadStart(0, -1); } public class PadStartWithPadding @@ -105,7 +105,7 @@ public void PadStartWithSelectorWithNegativeWidth() [Test] public void PadStartWithSelectorIsLazy() { - new BreakingSequence().PadStart(0, BreakingFunc.Of()); + _ = new BreakingSequence().PadStart(0, BreakingFunc.Of()); } public class PadStartWithSelector diff --git a/MoreLinq.Test/PadTest.cs b/MoreLinq.Test/PadTest.cs index 4537bdca0..cbe323d28 100644 --- a/MoreLinq.Test/PadTest.cs +++ b/MoreLinq.Test/PadTest.cs @@ -31,13 +31,13 @@ public void PadNegativeWidth() [Test] public void PadIsLazy() { - new BreakingSequence().Pad(0); + _ = new BreakingSequence().Pad(0); } [Test] public void PadWithFillerIsLazy() { - new BreakingSequence().Pad(0, new object()); + _ = new BreakingSequence().Pad(0, new object()); } public class ValueTypeElements diff --git a/MoreLinq.Test/PairwiseTest.cs b/MoreLinq.Test/PairwiseTest.cs index f205d99a3..5dace66b8 100644 --- a/MoreLinq.Test/PairwiseTest.cs +++ b/MoreLinq.Test/PairwiseTest.cs @@ -25,7 +25,7 @@ public class PairwiseTest [Test] public void PairwiseIsLazy() { - new BreakingSequence().Pairwise(BreakingFunc.Of()); + _ = new BreakingSequence().Pairwise(BreakingFunc.Of()); } [TestCase(0)] diff --git a/MoreLinq.Test/PartialSortByTest.cs b/MoreLinq.Test/PartialSortByTest.cs index e192e60fe..b4a28fedb 100644 --- a/MoreLinq.Test/PartialSortByTest.cs +++ b/MoreLinq.Test/PartialSortByTest.cs @@ -71,7 +71,7 @@ public void PartialSortWithComparer() [Test] public void PartialSortByIsLazy() { - new BreakingSequence().PartialSortBy(1, BreakingFunc.Of()); + _ = new BreakingSequence().PartialSortBy(1, BreakingFunc.Of()); } [Test, Ignore("TODO")] diff --git a/MoreLinq.Test/PartialSortTest.cs b/MoreLinq.Test/PartialSortTest.cs index 3c644e6ae..a838efdc3 100644 --- a/MoreLinq.Test/PartialSortTest.cs +++ b/MoreLinq.Test/PartialSortTest.cs @@ -76,7 +76,7 @@ public void PartialSortWithComparer() [Test] public void PartialSortIsLazy() { - new BreakingSequence().PartialSort(1); + _ = new BreakingSequence().PartialSort(1); } [Test, Ignore("TODO")] diff --git a/MoreLinq.Test/PartitionTest.cs b/MoreLinq.Test/PartitionTest.cs index cdc4ac19c..61887a535 100644 --- a/MoreLinq.Test/PartitionTest.cs +++ b/MoreLinq.Test/PartitionTest.cs @@ -75,7 +75,7 @@ public void PartitionNullableBooleanGrouping() var xs = new int?[] { 1, 2, 3, null, 5, 6, 7, null, 9, 10 }; var (lt5, gte5, nils) = - xs.GroupBy(x => x != null ? x < 5 : (bool?) null) + xs.GroupBy(x => x != null ? x < 5 : (bool?)null) .Partition((t, f, n) => Tuple.Create(t, f, n)); Assert.That(lt5, Is.EqualTo(new[] { 1, 2, 3 })); diff --git a/MoreLinq.Test/PermutationsTest.cs b/MoreLinq.Test/PermutationsTest.cs index 231e4c601..892d3ea9b 100644 --- a/MoreLinq.Test/PermutationsTest.cs +++ b/MoreLinq.Test/PermutationsTest.cs @@ -170,7 +170,7 @@ public void TestHigherCardinalityPermutations() [Test] public void TestPermutationsIsLazy() { - new BreakingSequence().Permutations(); + _ = new BreakingSequence().Permutations(); } /// diff --git a/MoreLinq.Test/PipeTest.cs b/MoreLinq.Test/PipeTest.cs index 33eeb1f6c..9fb1f1f53 100644 --- a/MoreLinq.Test/PipeTest.cs +++ b/MoreLinq.Test/PipeTest.cs @@ -39,7 +39,7 @@ public void PipeWithSequence() [Test] public void PipeIsLazy() { - new BreakingSequence().Pipe(BreakingAction.Of()); + _ = new BreakingSequence().Pipe(BreakingAction.Of()); } [Test] diff --git a/MoreLinq.Test/PreScanTest.cs b/MoreLinq.Test/PreScanTest.cs index 1f8c996c6..be767ab8d 100644 --- a/MoreLinq.Test/PreScanTest.cs +++ b/MoreLinq.Test/PreScanTest.cs @@ -25,7 +25,7 @@ public class PreScanTest [Test] public void PreScanIsLazy() { - new BreakingSequence().PreScan(BreakingFunc.Of(), 0); + _ = new BreakingSequence().PreScan(BreakingFunc.Of(), 0); } [Test] diff --git a/MoreLinq.Test/PrependTest.cs b/MoreLinq.Test/PrependTest.cs index a13e3fb77..eaaad5c81 100644 --- a/MoreLinq.Test/PrependTest.cs +++ b/MoreLinq.Test/PrependTest.cs @@ -54,7 +54,7 @@ public void PrependWithNullHead() [Test] public void PrependIsLazyInTailSequence() { - new BreakingSequence().Prepend("head"); + _ = new BreakingSequence().Prepend("head"); } [TestCaseSource(nameof(PrependManySource))] @@ -80,7 +80,7 @@ into e [Test] public void PrependWithSharedSource() { - var first = new [] { 1 }.Prepend(2); + var first = new[] { 1 }.Prepend(2); var second = first.Prepend(3).Prepend(4); var third = first.Prepend(4).Prepend(8); diff --git a/MoreLinq.Test/Program.cs b/MoreLinq.Test/Program.cs index 80f6ddf0d..e13667d10 100644 --- a/MoreLinq.Test/Program.cs +++ b/MoreLinq.Test/Program.cs @@ -15,19 +15,12 @@ // limitations under the License. #endregion -namespace MoreLinq.Test -{ - using System; - using System.Reflection; - using NUnit.Common; - using NUnitLite; +#pragma warning disable CA1852 // Seal internal types (false positive) - static class Program - { - static int Main(string[] args) - { - using var writer = new ExtendedTextWrapper(Console.Out); - return new AutoRun(typeof(Program).GetTypeInfo().Assembly).Execute(args, writer, Console.In); - } - } -} +using System; +using System.Reflection; +using NUnit.Common; +using NUnitLite; + +using var writer = new ExtendedTextWrapper(Console.Out); +return new AutoRun(typeof(Program).GetTypeInfo().Assembly).Execute(args, writer, Console.In); diff --git a/MoreLinq.Test/RandomSubsetTest.cs b/MoreLinq.Test/RandomSubsetTest.cs index 265abdbbb..5b4eb3ff2 100644 --- a/MoreLinq.Test/RandomSubsetTest.cs +++ b/MoreLinq.Test/RandomSubsetTest.cs @@ -33,8 +33,8 @@ public class RandomSubsetTest [Test] public void TestRandomSubsetIsLazy() { - new BreakingSequence().RandomSubset(10); - new BreakingSequence().RandomSubset(10, new Random()); + _ = new BreakingSequence().RandomSubset(10); + _ = new BreakingSequence().RandomSubset(10, new Random()); } /// @@ -240,7 +240,7 @@ static double RelativeStandardDeviation(IEnumerable values) { var average = values.Average(); var standardDeviation = StandardDeviationInternal(values, average); - return (standardDeviation * 100.0) / average; + return standardDeviation * 100.0 / average; } static double StandardDeviationInternal(IEnumerable values, double average) diff --git a/MoreLinq.Test/RankTest.cs b/MoreLinq.Test/RankTest.cs index f63ec1def..ad36c7afb 100644 --- a/MoreLinq.Test/RankTest.cs +++ b/MoreLinq.Test/RankTest.cs @@ -33,7 +33,7 @@ public class RankTests [Test] public void TestRankIsLazy() { - new BreakingSequence().Rank(); + _ = new BreakingSequence().Rank(); } /// @@ -42,7 +42,7 @@ public void TestRankIsLazy() [Test] public void TestRankByIsLazy() { - new BreakingSequence().RankBy(BreakingFunc.Of()); + _ = new BreakingSequence().RankBy(BreakingFunc.Of()); } /// @@ -175,7 +175,7 @@ public void TestRankCustomComparer() { const int count = 10; var ordinals = Enumerable.Range(1, count); - var sequence = ordinals.Select( x => new DateTime(2010,x,20-x) ); + var sequence = ordinals.Select(x => new DateTime(2010, x, 20 - x)); // invert the CompareTo operation to Rank in reverse order (ascending to descending) using var tsA = sequence.AsTestingSequence(); var resultA = tsA.Rank(Comparer.Create((a, b) => -a.CompareTo(b))); diff --git a/MoreLinq.Test/RepeatTest.cs b/MoreLinq.Test/RepeatTest.cs index 12c8b2bf6..be5c0916c 100644 --- a/MoreLinq.Test/RepeatTest.cs +++ b/MoreLinq.Test/RepeatTest.cs @@ -31,7 +31,7 @@ public class RepeatTest [Test] public void TestRepeatIsLazy() { - new BreakingSequence().Repeat(5); + _ = new BreakingSequence().Repeat(5); } /// @@ -109,7 +109,7 @@ public void TestRepeatForeverBehaviorManyElementsList() [Test] public void TestRepeatForeverIsLazy() { - new BreakingSequence().Repeat(); + _ = new BreakingSequence().Repeat(); } } } diff --git a/MoreLinq.Test/ReturnTest.cs b/MoreLinq.Test/ReturnTest.cs index fda98990b..769d7168d 100644 --- a/MoreLinq.Test/ReturnTest.cs +++ b/MoreLinq.Test/ReturnTest.cs @@ -140,7 +140,7 @@ static IEnumerable UnsupportedActions(string testName) => from ma in new (string MethodName, Action Action)[] { ("Add" , () => SomeSingleton.List.Add(new object())), - ("Clear" , () => SomeSingleton.Collection.Clear()), + ("Clear" , SomeSingleton.Collection.Clear), ("Remove" , () => SomeSingleton.Collection.Remove(SomeSingleton.Item)), ("RemoveAt", () => SomeSingleton.List.RemoveAt(0)), ("Insert" , () => SomeSingleton.List.Insert(0, new object())), diff --git a/MoreLinq.Test/RunLengthEncodeTest.cs b/MoreLinq.Test/RunLengthEncodeTest.cs index 707d61d55..dd442ad59 100644 --- a/MoreLinq.Test/RunLengthEncodeTest.cs +++ b/MoreLinq.Test/RunLengthEncodeTest.cs @@ -33,8 +33,8 @@ public class RunLengthEncodeTests [Test] public void TestRunLengthEncodeIsLazy() { - new BreakingSequence().RunLengthEncode(); - new BreakingSequence().RunLengthEncode(EqualityComparer.Default); + _ = new BreakingSequence().RunLengthEncode(); + _ = new BreakingSequence().RunLengthEncode(EqualityComparer.Default); } /// diff --git a/MoreLinq.Test/ScanByTest.cs b/MoreLinq.Test/ScanByTest.cs index 40414fd3c..8879fc05c 100644 --- a/MoreLinq.Test/ScanByTest.cs +++ b/MoreLinq.Test/ScanByTest.cs @@ -26,10 +26,10 @@ public class ScanByTest [Test] public void ScanByIsLazy() { - new BreakingSequence().ScanBy( - BreakingFunc.Of(), - BreakingFunc.Of(), - BreakingFunc.Of()); + var bs = new BreakingSequence(); + _ = bs.ScanBy(BreakingFunc.Of(), + BreakingFunc.Of(), + BreakingFunc.Of()); } [Test] diff --git a/MoreLinq.Test/ScanRightTest.cs b/MoreLinq.Test/ScanRightTest.cs index 711f9ed68..0b3e1a916 100644 --- a/MoreLinq.Test/ScanRightTest.cs +++ b/MoreLinq.Test/ScanRightTest.cs @@ -74,7 +74,7 @@ public void ScanRight(SourceKind sourceKind) [Test] public void ScanRightIsLazy() { - new BreakingSequence().ScanRight(BreakingFunc.Of()); + _ = new BreakingSequence().ScanRight(BreakingFunc.Of()); } // ScanRight(source, seed, func) @@ -111,7 +111,7 @@ public void ScanRightSeed() [Test] public void ScanRightSeedIsLazy() { - new BreakingSequence().ScanRight(string.Empty, BreakingFunc.Of()); + _ = new BreakingSequence().ScanRight(string.Empty, BreakingFunc.Of()); } } } diff --git a/MoreLinq.Test/ScanTest.cs b/MoreLinq.Test/ScanTest.cs index 65e6eed10..6a859d4ae 100644 --- a/MoreLinq.Test/ScanTest.cs +++ b/MoreLinq.Test/ScanTest.cs @@ -39,14 +39,14 @@ public void ScanSum() [Test] public void ScanIsLazy() { - new BreakingSequence().Scan(BreakingFunc.Of()); + _ = new BreakingSequence().Scan(BreakingFunc.Of()); } [Test] public void ScanDoesNotIterateExtra() { var sequence = Enumerable.Range(1, 3).Concat(new BreakingSequence()).Scan(SampleData.Plus); - var gold = new[] {1, 3, 6}; + var gold = new[] { 1, 3, 6 }; Assert.That(sequence.Consume, Throws.BreakException); sequence.Take(3).AssertSequenceEqual(gold); } @@ -68,7 +68,7 @@ public void SeededScanSum() [Test] public void SeededScanIsLazy() { - new BreakingSequence().Scan(null, BreakingFunc.Of()); + _ = new BreakingSequence().Scan(null, BreakingFunc.Of()); } [Test] diff --git a/MoreLinq.Test/Scope.cs b/MoreLinq.Test/Scope.cs index 27a93c306..8a7889113 100644 --- a/MoreLinq.Test/Scope.cs +++ b/MoreLinq.Test/Scope.cs @@ -23,16 +23,8 @@ abstract class Scope : IDisposable { readonly T _old; - protected Scope(T current) - { - _old = current; - } - - public virtual void Dispose() - { - Restore(_old); - } - + protected Scope(T current) => _old = current; + public virtual void Dispose() => Restore(_old); protected abstract void Restore(T old); } } diff --git a/MoreLinq.Test/SegmentTest.cs b/MoreLinq.Test/SegmentTest.cs index 3ece846b5..e4b587120 100644 --- a/MoreLinq.Test/SegmentTest.cs +++ b/MoreLinq.Test/SegmentTest.cs @@ -33,9 +33,9 @@ public class SegmentTests [Test] public void TestSegmentIsLazy() { - new BreakingSequence().Segment(BreakingFunc.Of()); - new BreakingSequence().Segment(BreakingFunc.Of()); - new BreakingSequence().Segment(BreakingFunc.Of()); + _ = new BreakingSequence().Segment(BreakingFunc.Of()); + _ = new BreakingSequence().Segment(BreakingFunc.Of()); + _ = new BreakingSequence().Segment(BreakingFunc.Of()); } /// diff --git a/MoreLinq.Test/ShuffleTest.cs b/MoreLinq.Test/ShuffleTest.cs index eeb82edc0..986189a03 100644 --- a/MoreLinq.Test/ShuffleTest.cs +++ b/MoreLinq.Test/ShuffleTest.cs @@ -23,12 +23,12 @@ namespace MoreLinq.Test [TestFixture] public class ShuffleTest { - static Random seed = new(12345); + static readonly Random Seed = new(12345); [Test] public void ShuffleIsLazy() { - new BreakingSequence().Shuffle(); + _ = new BreakingSequence().Shuffle(); } [Test] @@ -65,14 +65,14 @@ public void ShuffleIsIdempotent() [Test] public void ShuffleSeedIsLazy() { - new BreakingSequence().Shuffle(seed); + _ = new BreakingSequence().Shuffle(Seed); } [Test] public void ShuffleSeed() { var source = Enumerable.Range(1, 100); - var result = source.Shuffle(seed); + var result = source.Shuffle(Seed); Assert.That(result, Is.Not.EqualTo(source)); Assert.That(result.OrderBy(x => x), Is.EqualTo(source)); @@ -82,7 +82,7 @@ public void ShuffleSeed() public void ShuffleSeedWithEmptySequence() { var source = Enumerable.Empty(); - var result = source.Shuffle(seed); + var result = source.Shuffle(Seed); Assert.That(result, Is.Empty); } @@ -94,7 +94,7 @@ public void ShuffleSeedIsIdempotent() var sequenceClone = sequence.ToArray(); // force complete enumeration of random subsets - sequence.Shuffle(seed).Consume(); + sequence.Shuffle(Seed).Consume(); // verify the original sequence is untouched Assert.That(sequence, Is.EqualTo(sequenceClone)); diff --git a/MoreLinq.Test/SkipLastTest.cs b/MoreLinq.Test/SkipLastTest.cs index 715f53be4..dfdbad739 100644 --- a/MoreLinq.Test/SkipLastTest.cs +++ b/MoreLinq.Test/SkipLastTest.cs @@ -54,7 +54,7 @@ public void SkipLastWithSequenceShorterThanCount(int skip) [Test] public void SkipLastIsLazy() { - new BreakingSequence().SkipLast(1); + _ = new BreakingSequence().SkipLast(1); } } } diff --git a/MoreLinq.Test/SkipUntilTest.cs b/MoreLinq.Test/SkipUntilTest.cs index 373945869..ed327b72b 100644 --- a/MoreLinq.Test/SkipUntilTest.cs +++ b/MoreLinq.Test/SkipUntilTest.cs @@ -48,7 +48,7 @@ public void SkipUntilPredicateBecomesTrueHalfWay() [Test] public void SkipUntilEvaluatesSourceLazily() { - new BreakingSequence().SkipUntil(x => x.Length == 0); + _ = new BreakingSequence().SkipUntil(x => x.Length == 0); } [Test] diff --git a/MoreLinq.Test/SliceTest.cs b/MoreLinq.Test/SliceTest.cs index e5fd11c56..d7498b946 100644 --- a/MoreLinq.Test/SliceTest.cs +++ b/MoreLinq.Test/SliceTest.cs @@ -32,7 +32,7 @@ public class SliceTests [Test] public void TestSliceIsLazy() { - new BreakingSequence().Slice(10, 10); + _ = new BreakingSequence().Slice(10, 10); } /// diff --git a/MoreLinq.Test/SortedMergeTest.cs b/MoreLinq.Test/SortedMergeTest.cs index 4428e4c5b..a9ddb706b 100644 --- a/MoreLinq.Test/SortedMergeTest.cs +++ b/MoreLinq.Test/SortedMergeTest.cs @@ -36,7 +36,7 @@ public void TestSortedMergeIsLazy() var sequenceA = new BreakingSequence(); var sequenceB = new BreakingSequence(); - sequenceA.SortedMerge(OrderByDirection.Ascending, sequenceB); + _ = sequenceA.SortedMerge(OrderByDirection.Ascending, sequenceB); } /// diff --git a/MoreLinq.Test/StartsWithTest.cs b/MoreLinq.Test/StartsWithTest.cs index 99d3f01c0..00b386d1b 100644 --- a/MoreLinq.Test/StartsWithTest.cs +++ b/MoreLinq.Test/StartsWithTest.cs @@ -24,17 +24,17 @@ namespace MoreLinq.Test [TestFixture] public class StartsWithTest { - [TestCase(new[] {1, 2, 3}, new[] {1, 2}, ExpectedResult = true)] - [TestCase(new[] {1, 2, 3}, new[] {1, 2, 3}, ExpectedResult = true)] - [TestCase(new[] {1, 2, 3}, new[] {1, 2, 3, 4}, ExpectedResult = false)] + [TestCase(new[] { 1, 2, 3 }, new[] { 1, 2 }, ExpectedResult = true)] + [TestCase(new[] { 1, 2, 3 }, new[] { 1, 2, 3 }, ExpectedResult = true)] + [TestCase(new[] { 1, 2, 3 }, new[] { 1, 2, 3, 4 }, ExpectedResult = false)] public bool StartsWithWithIntegers(IEnumerable first, IEnumerable second) { return first.StartsWith(second); } - [TestCase(new[] {'1', '2', '3'}, new[] {'1', '2'}, ExpectedResult = true)] - [TestCase(new[] {'1', '2', '3'}, new[] {'1', '2', '3'}, ExpectedResult = true)] - [TestCase(new[] {'1', '2', '3'}, new[] {'1', '2', '3', '4'}, ExpectedResult = false)] + [TestCase(new[] { '1', '2', '3' }, new[] { '1', '2' }, ExpectedResult = true)] + [TestCase(new[] { '1', '2', '3' }, new[] { '1', '2', '3' }, ExpectedResult = true)] + [TestCase(new[] { '1', '2', '3' }, new[] { '1', '2', '3', '4' }, ExpectedResult = false)] public bool StartsWithWithChars(IEnumerable first, IEnumerable second) { return first.StartsWith(second); @@ -58,7 +58,7 @@ public void StartsWithReturnsTrueIfBothEmpty() [Test] public void StartsWithReturnsFalseIfOnlyFirstIsEmpty() { - Assert.That(new int[0].StartsWith(new[] {1,2,3}), Is.False); + Assert.That(new int[0].StartsWith(new[] { 1, 2, 3 }), Is.False); } [TestCase("", "", ExpectedResult = true)] @@ -72,18 +72,18 @@ public bool StartsWithReturnsTrueIfSecondIsEmpty(string first, string second) [Test] public void StartsWithDisposesBothSequenceEnumerators() { - using var first = TestingSequence.Of(1,2,3); + using var first = TestingSequence.Of(1, 2, 3); using var second = TestingSequence.Of(1); - first.StartsWith(second); + _ = first.StartsWith(second); } [Test] [SuppressMessage("ReSharper", "RedundantArgumentDefaultValue")] public void StartsWithUsesSpecifiedEqualityComparerOrDefault() { - var first = new[] {1,2,3}; - var second = new[] {4,5,6}; + var first = new[] { 1, 2, 3 }; + var second = new[] { 4, 5, 6 }; Assert.That(first.StartsWith(second), Is.False); Assert.That(first.StartsWith(second, null), Is.False); diff --git a/MoreLinq.Test/SubjectTest.cs b/MoreLinq.Test/SubjectTest.cs index fe44b2485..235aa6263 100644 --- a/MoreLinq.Test/SubjectTest.cs +++ b/MoreLinq.Test/SubjectTest.cs @@ -48,10 +48,9 @@ public void OnNextObservations() var subject = new Subject(); - Subscribe(subject, x => a = x); - Subscribe(subject, x => b = x); - - subject.OnNext(42); + using (Subscribe(subject, x => a = x)) + using (Subscribe(subject, x => b = x)) + subject.OnNext(42); Assert.That(a, Is.EqualTo(42)); Assert.That(b, Is.EqualTo(42)); @@ -64,12 +63,11 @@ public void OnErrorObservations() Exception? error2 = null; var subject = new Subject(); - - Subscribe(subject, onError: e => error1 = e); - Subscribe(subject, onError: e => error2 = e); - var error = new TestException(); - subject.OnError(error); + + using (Subscribe(subject, onError: e => error1 = e)) + using (Subscribe(subject, onError: e => error2 = e)) + subject.OnError(error); Assert.That(error1, Is.SameAs(error)); Assert.That(error2, Is.SameAs(error)); @@ -83,10 +81,9 @@ public void OnCompletedObservations() var subject = new Subject(); - Subscribe(subject, onCompleted: () => completed1 = true); - Subscribe(subject, onCompleted: () => completed2 = true); - - subject.OnCompleted(); + using (Subscribe(subject, onCompleted: () => completed1 = true)) + using (Subscribe(subject, onCompleted: () => completed2 = true)) + subject.OnCompleted(); Assert.That(completed1, Is.True); Assert.That(completed2, Is.True); @@ -101,13 +98,16 @@ public void SubscriptionDisposal() var subject = new Subject(); Subscribe(subject).Dispose(); - Subscribe(subject, x => a = x); + using var s1 = Subscribe(subject, x => a = x); Subscribe(subject).Dispose(); - Subscribe(subject, x => b = x); + using var s2 = Subscribe(subject, x => b = x); Subscribe(subject).Dispose(); subject.OnNext(42); + s1.Dispose(); + s2.Dispose(); + Assert.That(a, Is.EqualTo(42)); Assert.That(b, Is.EqualTo(42)); } @@ -131,9 +131,10 @@ public void SubscriptionPostCompletion() var subject = new Subject(); subject.OnCompleted(); - Subscribe(subject, onCompleted: () => completed = true); - - Assert.That(completed, Is.True); + using (Subscribe(subject, onCompleted: () => completed = true)) + { + Assert.That(completed, Is.True); + } } [Test] @@ -144,45 +145,54 @@ public void SubscriptionPostError() var error = new TestException(); subject.OnError(error); - Subscribe(subject, onError: e => observedError = e); - - Assert.That(observedError, Is.SameAs(error)); + using (Subscribe(subject, onError: e => observedError = e)) + { + Assert.That(observedError, Is.SameAs(error)); + } } [Test] public void OnNextMutedWhenCompleted() { var subject = new Subject(); - Subscribe(subject, onCompleted: delegate { }); - subject.OnCompleted(); - subject.OnNext(42); + using (Subscribe(subject, onCompleted: delegate { })) + { + subject.OnCompleted(); + subject.OnNext(42); + } } [Test] public void OnErrorMutedWhenCompleted() { var subject = new Subject(); - Subscribe(subject, onCompleted: delegate { }); - subject.OnCompleted(); - subject.OnError(new TestException()); + using (Subscribe(subject, onCompleted: delegate { })) + { + subject.OnCompleted(); + subject.OnError(new TestException()); + } } [Test] public void OnNextMutedWhenErrored() { var subject = new Subject(); - Subscribe(subject, onError: delegate { }); - subject.OnError(new TestException()); - subject.OnNext(42); + using (Subscribe(subject, onError: delegate { })) + { + subject.OnError(new TestException()); + subject.OnNext(42); + } } [Test] public void OnCompleteMutedWhenErrored() { var subject = new Subject(); - Subscribe(subject, onError: delegate { }); - subject.OnError(new TestException()); - subject.OnCompleted(); + using (Subscribe(subject, onError: delegate { })) + { + subject.OnError(new TestException()); + subject.OnCompleted(); + } } [Test] @@ -190,10 +200,11 @@ public void CompletesOnce() { var count = 0; var subject = new Subject(); - Subscribe(subject, onCompleted: () => count++); - - subject.OnCompleted(); - subject.OnCompleted(); + using (Subscribe(subject, onCompleted: () => count++)) + { + subject.OnCompleted(); + subject.OnCompleted(); + } Assert.That(count, Is.EqualTo(1)); } @@ -203,10 +214,11 @@ public void ErrorsOnce() { var count = 0; var subject = new Subject(); - Subscribe(subject, onError: _ => count++); - - subject.OnError(new TestException()); - subject.OnError(new TestException()); + using (Subscribe(subject, onError: _ => count++)) + { + subject.OnError(new TestException()); + subject.OnError(new TestException()); + } Assert.That(count, Is.EqualTo(1)); } diff --git a/MoreLinq.Test/SubsetTest.cs b/MoreLinq.Test/SubsetTest.cs index e08174ef8..4f55cb70b 100644 --- a/MoreLinq.Test/SubsetTest.cs +++ b/MoreLinq.Test/SubsetTest.cs @@ -32,8 +32,8 @@ public class SubsetTest [Test] public void TestSubsetsIsLazy() { - new BreakingSequence().Subsets(); - new BreakingSequence().Subsets(5); + _ = new BreakingSequence().Subsets(); + _ = new BreakingSequence().Subsets(5); } /// diff --git a/MoreLinq.Test/TagFirstLastTest.cs b/MoreLinq.Test/TagFirstLastTest.cs index 484904a9d..70ed83974 100644 --- a/MoreLinq.Test/TagFirstLastTest.cs +++ b/MoreLinq.Test/TagFirstLastTest.cs @@ -34,7 +34,7 @@ public void TagFirstLastDoesOneLookAhead() [Test] public void TagFirstLastIsLazy() { - new BreakingSequence().TagFirstLast(BreakingFunc.Of()); + _ = new BreakingSequence().TagFirstLast(BreakingFunc.Of()); } [Test] diff --git a/MoreLinq.Test/TakeEveryTest.cs b/MoreLinq.Test/TakeEveryTest.cs index a3fc857cf..84962c9ab 100644 --- a/MoreLinq.Test/TakeEveryTest.cs +++ b/MoreLinq.Test/TakeEveryTest.cs @@ -66,7 +66,7 @@ public void TakeEveryThirdOnNonEmptySequence() [Test] public void TakeEveryIsLazy() { - new BreakingSequence().TakeEvery(1); + _ = new BreakingSequence().TakeEvery(1); } } } diff --git a/MoreLinq.Test/TakeLastTest.cs b/MoreLinq.Test/TakeLastTest.cs index 31548d411..fdbd8f923 100644 --- a/MoreLinq.Test/TakeLastTest.cs +++ b/MoreLinq.Test/TakeLastTest.cs @@ -51,13 +51,13 @@ public void TakeLastWithNegativeCount() [Test] public void TakeLastIsLazy() { - new BreakingSequence().TakeLast(1); + _ = new BreakingSequence().TakeLast(1); } [Test] public void TakeLastDisposesSequenceEnumerator() { - using var seq = TestingSequence.Of(1,2,3); + using var seq = TestingSequence.Of(1, 2, 3); seq.TakeLast(1).Consume(); } diff --git a/MoreLinq.Test/TakeUntilTest.cs b/MoreLinq.Test/TakeUntilTest.cs index 4a00fc6f6..fb7f47635 100644 --- a/MoreLinq.Test/TakeUntilTest.cs +++ b/MoreLinq.Test/TakeUntilTest.cs @@ -46,7 +46,7 @@ public void TakeUntilPredicateBecomesTrueHalfWay() [Test] public void TakeUntilEvaluatesSourceLazily() { - new BreakingSequence().TakeUntil(x => x.Length == 0); + _ = new BreakingSequence().TakeUntil(x => x.Length == 0); } [Test] diff --git a/MoreLinq.Test/TestExtensions.cs b/MoreLinq.Test/TestExtensions.cs index 0cb95b4e2..e327c09e8 100644 --- a/MoreLinq.Test/TestExtensions.cs +++ b/MoreLinq.Test/TestExtensions.cs @@ -87,9 +87,8 @@ internal static IEnumerable GenerateSplits(this string str, params char[ yield return split; } - internal static IEnumerable ToSourceKind(this IEnumerable input, SourceKind sourceKind) - { - return sourceKind switch + internal static IEnumerable ToSourceKind(this IEnumerable input, SourceKind sourceKind) => + sourceKind switch { SourceKind.Sequence => input.Select(x => x), SourceKind.BreakingList => new BreakingList(input.ToList()), @@ -98,6 +97,5 @@ internal static IEnumerable ToSourceKind(this IEnumerable input, Source SourceKind.BreakingReadOnlyCollection => new BreakingReadOnlyCollection(input.ToList()), _ => throw new ArgumentException(null, nameof(sourceKind)) }; - } } } diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs index e800dd7c0..f9cbe83ac 100644 --- a/MoreLinq.Test/ToDataTableTest.cs +++ b/MoreLinq.Test/ToDataTableTest.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#nullable enable - namespace MoreLinq.Test { using System; @@ -56,12 +54,10 @@ public TestObject(int key) readonly IReadOnlyCollection _testObjects; - public ToDataTableTest() - { + public ToDataTableTest() => _testObjects = Enumerable.Range(0, 3) .Select(i => new TestObject(i)) .ToArray(); - } [Test] public void ToDataTableNullMemberExpressionMethod() @@ -76,7 +72,7 @@ public void ToDataTableNullMemberExpressionMethod() public void ToDataTableTableWithWrongColumnNames() { using var dt = new DataTable(); - dt.Columns.Add("Test"); + _ = dt.Columns.Add("Test"); Assert.That(() => _testObjects.ToDataTable(dt), Throws.ArgumentException("table")); @@ -86,9 +82,9 @@ public void ToDataTableTableWithWrongColumnNames() public void ToDataTableTableWithWrongColumnDataType() { using var dt = new DataTable(); - dt.Columns.Add("AString", typeof(int)); + _ = dt.Columns.Add("AString", typeof(int)); - Assert.That(() => _testObjects.ToDataTable(dt, t=>t.AString), + Assert.That(() => _testObjects.ToDataTable(dt, t => t.AString), Throws.ArgumentException("table")); } @@ -167,17 +163,17 @@ public void ToDataTableWithSchema() { using var dt = new DataTable(); var columns = dt.Columns; - columns.Add("Column1", typeof(int)); - columns.Add("Value", typeof(string)); - columns.Add("Column3", typeof(int)); - columns.Add("Name", typeof(string)); + _ = columns.Add("Column1", typeof(int)); + _ = columns.Add("Value", typeof(string)); + _ = columns.Add("Column3", typeof(int)); + _ = columns.Add("Name", typeof(string)); var vars = Environment.GetEnvironmentVariables() .Cast() .ToArray(); - vars.Select(e => new { Name = e.Key.ToString(), Value = e.Value!.ToString() }) - .ToDataTable(dt, e => e.Name, e => e.Value); + _ = vars.Select(e => new { Name = e.Key.ToString(), Value = e.Value!.ToString() }) + .ToDataTable(dt, e => e.Name, e => e.Value); var rows = dt.Rows.Cast().ToArray(); Assert.That(rows.Length, Is.EqualTo(vars.Length)); diff --git a/MoreLinq.Test/TraceTest.cs b/MoreLinq.Test/TraceTest.cs index 5c9725a35..6e32ba55e 100644 --- a/MoreLinq.Test/TraceTest.cs +++ b/MoreLinq.Test/TraceTest.cs @@ -37,7 +37,7 @@ public void TraceSequence() [Test] public void TraceSequenceWithSomeNullElements() { - var trace = Lines(CaptureTrace(() => new int?[] {1, null, 2, null, 3}.Trace().Consume())); + var trace = Lines(CaptureTrace(() => new int?[] { 1, null, 2, null, 3 }.Trace().Consume())); trace.AssertSequenceEqual("1", string.Empty, "2", string.Empty, "3"); } @@ -93,7 +93,7 @@ static string CaptureTrace(Action action) { var writer = new StringWriter(); var listener = new TextWriterTraceListener(writer); - Trace.Listeners.Add(listener); + _ = Trace.Listeners.Add(listener); try { action(); diff --git a/MoreLinq.Test/TransposeTest.cs b/MoreLinq.Test/TransposeTest.cs index 70f3c6772..826e55687 100644 --- a/MoreLinq.Test/TransposeTest.cs +++ b/MoreLinq.Test/TransposeTest.cs @@ -27,7 +27,7 @@ public class TransposeTest [Test] public void TransposeIsLazy() { - new BreakingSequence>().Transpose(); + _ = new BreakingSequence>().Transpose(); } [Test] diff --git a/MoreLinq.Test/TraverseTest.cs b/MoreLinq.Test/TraverseTest.cs index 07736d9ac..163b3b401 100644 --- a/MoreLinq.Test/TraverseTest.cs +++ b/MoreLinq.Test/TraverseTest.cs @@ -26,13 +26,13 @@ public class TraverseTest [Test] public void TraverseDepthFirstFNullGenerator() { - MoreEnumerable.TraverseDepthFirst(new object(), _ => new BreakingSequence()); + _ = MoreEnumerable.TraverseDepthFirst(new object(), _ => new BreakingSequence()); } [Test] public void TraverseBreadthFirstIsStreaming() { - MoreEnumerable.TraverseBreadthFirst(new object(), _ => new BreakingSequence()); + _ = MoreEnumerable.TraverseBreadthFirst(new object(), _ => new BreakingSequence()); } [Test] diff --git a/MoreLinq.Test/TrySingleTest.cs b/MoreLinq.Test/TrySingleTest.cs index 5dfffbcaf..45186c623 100644 --- a/MoreLinq.Test/TrySingleTest.cs +++ b/MoreLinq.Test/TrySingleTest.cs @@ -92,7 +92,7 @@ public IEnumerator GetEnumerator() sealed class BreakingSingleElementCollection : BreakingSingleElementCollectionBase, ICollection { - public BreakingSingleElementCollection(T element) : base(element) {} + public BreakingSingleElementCollection(T element) : base(element) { } public void Add(T item) => throw new NotImplementedException(); public void Clear() => throw new NotImplementedException(); @@ -105,7 +105,7 @@ public BreakingSingleElementCollection(T element) : base(element) {} sealed class BreakingSingleElementReadOnlyCollection : BreakingSingleElementCollectionBase, IReadOnlyCollection { - public BreakingSingleElementReadOnlyCollection(T element) : base(element) {} + public BreakingSingleElementReadOnlyCollection(T element) : base(element) { } } [TestCase(SourceKind.Sequence)] diff --git a/MoreLinq.Test/UnfoldTest.cs b/MoreLinq.Test/UnfoldTest.cs index 6a43d16c7..0f5a581cb 100644 --- a/MoreLinq.Test/UnfoldTest.cs +++ b/MoreLinq.Test/UnfoldTest.cs @@ -52,10 +52,10 @@ public void UnfoldFiniteSequence() [Test] public void UnfoldIsLazy() { - MoreEnumerable.Unfold(0, BreakingFunc.Of(), - BreakingFunc.Of<(int, int), bool>(), - BreakingFunc.Of<(int, int), int>(), - BreakingFunc.Of<(int, int), int>()); + _ = MoreEnumerable.Unfold(0, BreakingFunc.Of(), + BreakingFunc.Of<(int, int), bool>(), + BreakingFunc.Of<(int, int), int>(), + BreakingFunc.Of<(int, int), int>()); } diff --git a/MoreLinq.Test/WindowLeftTest.cs b/MoreLinq.Test/WindowLeftTest.cs index e24cf2dbd..05fbd1e74 100644 --- a/MoreLinq.Test/WindowLeftTest.cs +++ b/MoreLinq.Test/WindowLeftTest.cs @@ -26,20 +26,18 @@ public class WindowLeftTest [Test] public void WindowLeftIsLazy() { - new BreakingSequence().WindowLeft(1); + _ = new BreakingSequence().WindowLeft(1); } [Test] public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow() { var sequence = Enumerable.Range(0, 3); - using var e = sequence.WindowLeft(2).GetEnumerator(); + using var reader = sequence.WindowLeft(2).Read(); - e.MoveNext(); - var window1 = e.Current; + var window1 = reader.Read(); window1[1] = -1; - e.MoveNext(); - var window2 = e.Current; + var window2 = reader.Read(); Assert.That(window2[0], Is.EqualTo(1)); } @@ -48,13 +46,11 @@ public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow() public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow() { var sequence = Enumerable.Range(0, 3); - using var e = sequence.WindowLeft(2).GetEnumerator(); + using var reader = sequence.WindowLeft(2).Read(); - e.MoveNext(); - var window1 = e.Current; - e.MoveNext(); + var window1 = reader.Read(); window1[1] = -1; - var window2 = e.Current; + var window2 = reader.Read(); Assert.That(window2[0], Is.EqualTo(1)); } @@ -63,12 +59,10 @@ public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow() public void WindowModifiedDoesNotAffectPreviousWindow() { var sequence = Enumerable.Range(0, 3); - using var e = sequence.WindowLeft(2).GetEnumerator(); + using var reader = sequence.WindowLeft(2).Read(); - e.MoveNext(); - var window1 = e.Current; - e.MoveNext(); - var window2 = e.Current; + var window1 = reader.Read(); + var window2 = reader.Read(); window2[0] = -1; Assert.That(window1[1], Is.EqualTo(1)); diff --git a/MoreLinq.Test/WindowRightTest.cs b/MoreLinq.Test/WindowRightTest.cs index 57d5f5040..80fb3a08c 100644 --- a/MoreLinq.Test/WindowRightTest.cs +++ b/MoreLinq.Test/WindowRightTest.cs @@ -26,20 +26,18 @@ public class WindowRightTest [Test] public void WindowRightIsLazy() { - new BreakingSequence().WindowRight(1); + _ = new BreakingSequence().WindowRight(1); } [Test] public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow() { var sequence = Enumerable.Range(0, 3); - using var e = sequence.WindowRight(2).GetEnumerator(); + using var reader = sequence.WindowRight(2).Read(); - e.MoveNext(); - var window1 = e.Current; + var window1 = reader.Read(); window1[0] = -1; - e.MoveNext(); - var window2 = e.Current; + var window2 = reader.Read(); Assert.That(window2[0], Is.EqualTo(0)); } @@ -48,13 +46,11 @@ public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow() public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow() { var sequence = Enumerable.Range(0, 3); - using var e = sequence.WindowRight(2).GetEnumerator(); + using var reader = sequence.WindowRight(2).Read(); - e.MoveNext(); - var window1 = e.Current; - e.MoveNext(); + var window1 = reader.Read(); window1[0] = -1; - var window2 = e.Current; + var window2 = reader.Read(); Assert.That(window2[0], Is.EqualTo(0)); } @@ -63,12 +59,10 @@ public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow() public void WindowModifiedDoesNotAffectPreviousWindow() { var sequence = Enumerable.Range(0, 3); - using var e = sequence.WindowRight(2).GetEnumerator(); + using var reader = sequence.WindowRight(2).Read(); - e.MoveNext(); - var window1 = e.Current; - e.MoveNext(); - var window2 = e.Current; + var window1 = reader.Read(); + var window2 = reader.Read(); window2[0] = -1; Assert.That(window1[0], Is.EqualTo(0)); diff --git a/MoreLinq.Test/WindowTest.cs b/MoreLinq.Test/WindowTest.cs index fb5c93c97..5c5f30e6e 100644 --- a/MoreLinq.Test/WindowTest.cs +++ b/MoreLinq.Test/WindowTest.cs @@ -31,20 +31,18 @@ public class WindowTests [Test] public void TestWindowIsLazy() { - new BreakingSequence().Window(1); + _ = new BreakingSequence().Window(1); } [Test] public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow() { var sequence = Enumerable.Range(0, 3); - using var e = sequence.Window(2).GetEnumerator(); + using var reader = sequence.Window(2).Read(); - e.MoveNext(); - var window1 = e.Current; + var window1 = reader.Read(); window1[1] = -1; - e.MoveNext(); - var window2 = e.Current; + var window2 = reader.Read(); Assert.That(window2[0], Is.EqualTo(1)); } @@ -53,13 +51,11 @@ public void WindowModifiedBeforeMoveNextDoesNotAffectNextWindow() public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow() { var sequence = Enumerable.Range(0, 3); - using var e = sequence.Window(2).GetEnumerator(); + using var reader = sequence.Window(2).Read(); - e.MoveNext(); - var window1 = e.Current; - e.MoveNext(); + var window1 = reader.Read(); window1[1] = -1; - var window2 = e.Current; + var window2 = reader.Read(); Assert.That(window2[0], Is.EqualTo(1)); } @@ -68,12 +64,10 @@ public void WindowModifiedAfterMoveNextDoesNotAffectNextWindow() public void WindowModifiedDoesNotAffectPreviousWindow() { var sequence = Enumerable.Range(0, 3); - using var e = sequence.Window(2).GetEnumerator(); + using var reader = sequence.Window(2).Read(); - e.MoveNext(); - var window1 = e.Current; - e.MoveNext(); - var window2 = e.Current; + var window1 = reader.Read(); + var window2 = reader.Read(); window2[0] = -1; Assert.That(window1[1], Is.EqualTo(1)); diff --git a/MoreLinq.Test/ZipLongestTest.cs b/MoreLinq.Test/ZipLongestTest.cs index 7c3faaec7..3d07993a5 100644 --- a/MoreLinq.Test/ZipLongestTest.cs +++ b/MoreLinq.Test/ZipLongestTest.cs @@ -55,7 +55,7 @@ from e in new[] public void ZipLongestIsLazy() { var bs = new BreakingSequence(); - bs.ZipLongest(bs, BreakingFunc.Of()); + _ = bs.ZipLongest(bs, BreakingFunc.Of()); } [Test] @@ -66,7 +66,7 @@ public void ZipLongestDisposeSequencesEagerly() var zipped = shorter.ZipLongest(longer, Tuple.Create); var count = 0; - foreach(var _ in zipped.Take(10)) + foreach (var _ in zipped.Take(10)) { if (++count == 4) ((IDisposable)shorter).Dispose(); diff --git a/MoreLinq.Test/ZipShortestTest.cs b/MoreLinq.Test/ZipShortestTest.cs index 3a63b3660..5c0d1a75e 100644 --- a/MoreLinq.Test/ZipShortestTest.cs +++ b/MoreLinq.Test/ZipShortestTest.cs @@ -69,7 +69,7 @@ public void ZipShortestWithFirstSequnceLongerThanSecond() public void ZipShortestIsLazy() { var bs = new BreakingSequence(); - bs.ZipShortest(bs, BreakingFunc.Of()); + _ = bs.ZipShortest(bs, BreakingFunc.Of()); } [Test] diff --git a/MoreLinq/AggregateRight.cs b/MoreLinq/AggregateRight.cs index b3004919c..92bad8f54 100644 --- a/MoreLinq/AggregateRight.cs +++ b/MoreLinq/AggregateRight.cs @@ -47,12 +47,11 @@ public static TSource AggregateRight(this IEnumerable source, if (source == null) throw new ArgumentNullException(nameof(source)); if (func == null) throw new ArgumentNullException(nameof(func)); - var list = source.ToListLike(); - - if (list.Count == 0) - throw new InvalidOperationException("Sequence contains no elements."); - - return AggregateRightImpl(list, list[^1], func, list.Count - 1); + return source.ToListLike() switch + { + { Count: 0 } => throw new InvalidOperationException("Sequence contains no elements."), + var list => AggregateRightImpl(list, list[^1], func, list.Count - 1) + }; } /// diff --git a/MoreLinq/AssemblyInfo.cs b/MoreLinq/AssemblyInfo.cs index 28e64cc82..b41c26d8d 100644 --- a/MoreLinq/AssemblyInfo.cs +++ b/MoreLinq/AssemblyInfo.cs @@ -17,7 +17,6 @@ using System; using System.Reflection; -using System.Runtime.InteropServices; [assembly: AssemblyTitle("MoreLINQ")] [assembly: AssemblyDescription("Extensions to LINQ to Objects")] @@ -38,9 +37,9 @@ [assembly: CLSCompliant(true)] #if !NO_COM -[assembly: ComVisible(false)] +[assembly: System.Runtime.InteropServices.ComVisible(false)] // ID of the typelib if this project is exposed to COM. -[assembly: Guid("fc632c9d-390e-4902-8c1c-3e57b08c1d38")] +[assembly: System.Runtime.InteropServices.Guid("fc632c9d-390e-4902-8c1c-3e57b08c1d38")] #endif diff --git a/MoreLinq/AssertCount.cs b/MoreLinq/AssertCount.cs index f9467c7c1..916400abf 100644 --- a/MoreLinq/AssertCount.cs +++ b/MoreLinq/AssertCount.cs @@ -22,7 +22,7 @@ namespace MoreLinq static partial class MoreEnumerable { - #if MORELINQ +#if MORELINQ static readonly Func DefaultErrorSelector = OnAssertCountFailure; @@ -77,7 +77,7 @@ static Exception OnAssertCountFailure(int cmp, int count) => internal static string FormatSequenceLengthErrorMessage(int cmp, int count) => $"Sequence contains too {(cmp < 0 ? "few" : "many")} elements when exactly {count:N0} {(count == 1 ? "was" : "were")} expected."; - #endif +#endif static IEnumerable AssertCountImpl(IEnumerable source, int count, Func errorSelector) @@ -87,23 +87,23 @@ static IEnumerable AssertCountImpl(IEnumerable source if (errorSelector == null) throw new ArgumentNullException(nameof(errorSelector)); return - source.TryGetCollectionCount() is {} collectionCount + source.TryGetCollectionCount() is { } collectionCount ? collectionCount == count ? source : From(() => throw errorSelector(collectionCount.CompareTo(count), count)) : _(); IEnumerable _() + { + var iterations = 0; + foreach (var element in source) { - var iterations = 0; - foreach (var element in source) - { - iterations++; - if (iterations > count) - throw errorSelector(1, count); - yield return element; - } - if (iterations != count) - throw errorSelector(-1, count); + iterations++; + if (iterations > count) + throw errorSelector(1, count); + yield return element; } + if (iterations != count) + throw errorSelector(-1, count); + } } } } diff --git a/MoreLinq/Backsert.cs b/MoreLinq/Backsert.cs index 3b0a0b4bf..490e7702e 100644 --- a/MoreLinq/Backsert.cs +++ b/MoreLinq/Backsert.cs @@ -75,7 +75,7 @@ IEnumerable _() if (e.MoveNext()) { var (_, countdown) = e.Current; - if (countdown is {} n && n != index - 1) + if (countdown is { } n && n != index - 1) throw new ArgumentOutOfRangeException(nameof(index), "Insertion index is greater than the length of the first sequence."); do diff --git a/MoreLinq/CountDown.cs b/MoreLinq/CountDown.cs index 1f5f72dad..f5cb867f0 100644 --- a/MoreLinq/CountDown.cs +++ b/MoreLinq/CountDown.cs @@ -57,9 +57,9 @@ public static IEnumerable CountDown(this IEnumerable sou if (source == null) throw new ArgumentNullException(nameof(source)); if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return source.TryAsListLike() is {} listLike + return source.TryAsListLike() is { } listLike ? IterateList(listLike) - : source.TryGetCollectionCount() is {} collectionCount + : source.TryGetCollectionCount() is { } collectionCount ? IterateCollection(collectionCount) : IterateSequence(); @@ -75,7 +75,7 @@ IEnumerable IterateList(IListLike list) IEnumerable IterateCollection(int i) { foreach (var item in source) - yield return resultSelector(item, i-- <= count ? i : (int?) null); + yield return resultSelector(item, i-- <= count ? i : null); } IEnumerable IterateSequence() diff --git a/MoreLinq/CountMethods.cs b/MoreLinq/CountMethods.cs index d253dc7c8..c2eef6abb 100644 --- a/MoreLinq/CountMethods.cs +++ b/MoreLinq/CountMethods.cs @@ -167,11 +167,11 @@ public static int CompareCount(this IEnumerable first, if (first == null) throw new ArgumentNullException(nameof(first)); if (second == null) throw new ArgumentNullException(nameof(second)); - if (first.TryGetCollectionCount() is {} firstCount) + if (first.TryGetCollectionCount() is { } firstCount) { return firstCount.CompareTo(second.TryGetCollectionCount() ?? second.CountUpTo(firstCount + 1)); } - else if (second.TryGetCollectionCount() is {} secondCount) + else if (second.TryGetCollectionCount() is { } secondCount) { return first.CountUpTo(secondCount + 1).CompareTo(secondCount); } diff --git a/MoreLinq/Delegating.cs b/MoreLinq/Delegating.cs index fcdda4e5a..9b427e6c5 100644 --- a/MoreLinq/Delegating.cs +++ b/MoreLinq/Delegating.cs @@ -22,6 +22,8 @@ // https://github.com/atifaziz/Delegating +#pragma warning disable IDE0130 // Namespace does not match folder structure + namespace Delegating { using System; diff --git a/MoreLinq/EndsWith.cs b/MoreLinq/EndsWith.cs index 4c9664b79..3ff560bf5 100644 --- a/MoreLinq/EndsWith.cs +++ b/MoreLinq/EndsWith.cs @@ -74,11 +74,13 @@ public static bool EndsWith(this IEnumerable first, IEnumerable second, comparer ??= EqualityComparer.Default; List secondList; - return second.TryGetCollectionCount() is {} secondCount - ? first.TryGetCollectionCount() is {} firstCount && secondCount > firstCount +#pragma warning disable IDE0075 // Simplify conditional expression (makes it worse) + return second.TryGetCollectionCount() is { } secondCount + ? first.TryGetCollectionCount() is { } firstCount && secondCount > firstCount ? false : Impl(second, secondCount) : Impl(secondList = second.ToList(), secondList.Count); +#pragma warning restore IDE0075 // Simplify conditional expression bool Impl(IEnumerable snd, int count) { diff --git a/MoreLinq/ExceptBy.cs b/MoreLinq/ExceptBy.cs index d3faa6ea8..6a5e1f2c6 100644 --- a/MoreLinq/ExceptBy.cs +++ b/MoreLinq/ExceptBy.cs @@ -79,7 +79,9 @@ public static IEnumerable ExceptBy(this IEnumerable_() + return Impl(); + + IEnumerable Impl() { // TODO Use ToHashSet var keys = new HashSet(second.Select(keySelector), keyComparer); @@ -89,7 +91,7 @@ public static IEnumerable ExceptBy(this IEnumerable /// Represents options for a query whose results evaluate asynchronously. @@ -427,11 +426,11 @@ public static IAwaitQuery AwaitCompletion( return AwaitQuery.Create( - options => _(options.MaxConcurrency, - options.Scheduler ?? TaskScheduler.Default, - options.PreserveOrder)); + options => Impl(options.MaxConcurrency, + options.Scheduler ?? TaskScheduler.Default, + options.PreserveOrder)); - IEnumerable _(int? maxConcurrency, TaskScheduler scheduler, bool ordered) + IEnumerable Impl(int? maxConcurrency, TaskScheduler scheduler, bool ordered) { // A separate task will enumerate the source and launch tasks. // It will post all progress as notices to the collection below. @@ -467,7 +466,7 @@ IEnumerable _(int? maxConcurrency, TaskScheduler scheduler, bool ordere // completes and another, an end-notice, when all tasks have // completed. - Task.Factory.StartNew( + _ = Task.Factory.StartNew( async () => { try @@ -528,8 +527,10 @@ void PostNotice(Notice notice, var nextKey = 0; var holds = ordered ? new List<(int, T, Task)>() : null; +#pragma warning disable IDE0011 // Add braces using (var notice = notices.GetConsumingEnumerable(consumerCancellationTokenSource.Token) .GetEnumerator()) +#pragma warning restore IDE0011 // Add braces while (true) { try @@ -651,7 +652,7 @@ void OnPendingCompleted() onEnd(); } - var concurrencyGate = maxConcurrency is {} count + var concurrencyGate = maxConcurrency is { } count ? new ConcurrencyGate(count) : ConcurrencyGate.Unbounded; @@ -667,7 +668,7 @@ await concurrencyGate.EnterAsync(cancellationToken) return; } - Interlocked.Increment(ref pendingCount); + _ = Interlocked.Increment(ref pendingCount); var item = enumerator.Current; var task = starter(item); @@ -676,9 +677,7 @@ await concurrencyGate.EnterAsync(cancellationToken) // along with the necessary housekeeping, in case it // completes before maximum concurrency is reached. - #pragma warning disable 4014 // https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/cs4014 - - task.ContinueWith(cancellationToken: cancellationToken, + _ = task.ContinueWith(cancellationToken: cancellationToken, continuationOptions: TaskContinuationOptions.ExecuteSynchronously, scheduler: TaskScheduler.Current, continuationAction: t => @@ -691,8 +690,6 @@ await concurrencyGate.EnterAsync(cancellationToken) onTaskCompletion(item, t); OnPendingCompleted(); }); - - #pragma warning restore 4014 } OnPendingCompleted(); @@ -745,22 +742,22 @@ static class TupleComparer static class CompletedTask { - #if NETSTANDARD1_0 +#if NETSTANDARD1_0 public static readonly Task Instance = CreateCompletedTask(); static Task CreateCompletedTask() { - var tcs = new TaskCompletionSource(); + var tcs = new TaskCompletionSource(); tcs.SetResult(default); return tcs.Task; } - #else +#else public static readonly Task Instance = Task.CompletedTask; - #endif +#endif } sealed class ConcurrencyGate @@ -773,7 +770,7 @@ sealed class ConcurrencyGate _semaphore = semaphore; public ConcurrencyGate(int max) : - this(new SemaphoreSlim(max, max)) {} + this(new SemaphoreSlim(max, max)) { } public Task EnterAsync(CancellationToken token) { diff --git a/MoreLinq/Experimental/TrySingle.cs b/MoreLinq/Experimental/TrySingle.cs index e72bfbc82..881e4ee75 100644 --- a/MoreLinq/Experimental/TrySingle.cs +++ b/MoreLinq/Experimental/TrySingle.cs @@ -115,7 +115,7 @@ public static TResult TrySingle(this IEnumerable so }; return resultSelector(one, item); } - case {}: + case not null: return resultSelector(many, default); default: { diff --git a/MoreLinq/FallbackIfEmpty.cs b/MoreLinq/FallbackIfEmpty.cs index 30a16726e..2acbeae26 100644 --- a/MoreLinq/FallbackIfEmpty.cs +++ b/MoreLinq/FallbackIfEmpty.cs @@ -161,7 +161,7 @@ static IEnumerable FallbackIfEmptyImpl(IEnumerable source, int? count, T? fallback1, T? fallback2, T? fallback3, T? fallback4, IEnumerable? fallback) { - return source.TryGetCollectionCount() is {} collectionCount + return source.TryGetCollectionCount() is { } collectionCount ? collectionCount == 0 ? Fallback() : source : _(); diff --git a/MoreLinq/FillForward.cs b/MoreLinq/FillForward.cs index dd4b52aad..6d304a366 100644 --- a/MoreLinq/FillForward.cs +++ b/MoreLinq/FillForward.cs @@ -112,7 +112,7 @@ static IEnumerable FillForwardImpl(IEnumerable source, Func pr { if (predicate(item)) { - yield return seed is (true, {} someSeed) + yield return seed is (true, { } someSeed) ? fillSelector != null ? fillSelector(item, someSeed) : someSeed diff --git a/MoreLinq/Flatten.cs b/MoreLinq/Flatten.cs index 8de35aaf7..09e107d01 100644 --- a/MoreLinq/Flatten.cs +++ b/MoreLinq/Flatten.cs @@ -137,11 +137,11 @@ public static IEnumerable< { e = stack.Pop(); - reloop: + reloop: while (e.MoveNext()) { - if (selector(e.Current) is {} inner) + if (selector(e.Current) is { } inner) { stack.Push(e); e = inner.GetEnumerator(); diff --git a/MoreLinq/FullJoin.cs b/MoreLinq/FullJoin.cs index 877e35799..9b2da6d12 100644 --- a/MoreLinq/FullJoin.cs +++ b/MoreLinq/FullJoin.cs @@ -228,7 +228,9 @@ public static IEnumerable FullJoin( if (secondSelector == null) throw new ArgumentNullException(nameof(secondSelector)); if (bothSelector == null) throw new ArgumentNullException(nameof(bothSelector)); - return _(); IEnumerable _() + return Impl(); + + IEnumerable Impl() { var seconds = second.Select(e => new KeyValuePair(secondKeySelector(e), e)).ToArray(); var secondLookup = seconds.ToLookup(e => e.Key, e => e.Value, comparer); @@ -237,7 +239,7 @@ public static IEnumerable FullJoin( foreach (var fe in first) { var key = firstKeySelector(fe); - firstKeys.Add(key); + _ = firstKeys.Add(key); using var se = secondLookup[key].GetEnumerator(); diff --git a/MoreLinq/GroupAdjacent.cs b/MoreLinq/GroupAdjacent.cs index 162d23735..4dbd0243f 100644 --- a/MoreLinq/GroupAdjacent.cs +++ b/MoreLinq/GroupAdjacent.cs @@ -273,7 +273,7 @@ static IEnumerable GroupAdjacentImpl( var key = keySelector(iterator.Current); var element = elementSelector(iterator.Current); - if (group is (var k, {} members)) + if (group is (var k, { } members)) { if (comparer.Equals(k, key)) { @@ -290,7 +290,7 @@ static IEnumerable GroupAdjacentImpl( } { - if (group is (var k, {} members)) + if (group is (var k, { } members)) yield return resultSelector(k, members); } } @@ -304,9 +304,9 @@ public static Grouping Create(TKey key, IEnumera new(key, members); } - #if !NO_SERIALIZATION_ATTRIBUTES +#if !NO_SERIALIZATION_ATTRIBUTES [Serializable] - #endif +#endif sealed class Grouping : IGrouping { readonly IEnumerable _members; diff --git a/MoreLinq/Insert.cs b/MoreLinq/Insert.cs index 09181f47f..11c337ba3 100644 --- a/MoreLinq/Insert.cs +++ b/MoreLinq/Insert.cs @@ -53,7 +53,7 @@ public static IEnumerable Insert(this IEnumerable first, IEnumerable { if (first == null) throw new ArgumentNullException(nameof(first)); if (second == null) throw new ArgumentNullException(nameof(second)); - if (index < 0) throw new ArgumentOutOfRangeException(nameof(index), "Index cannot be negative."); + if (index < 0) throw new ArgumentOutOfRangeException(nameof(index), "Index cannot be negative."); return _(); IEnumerable _() { @@ -65,7 +65,7 @@ public static IEnumerable Insert(this IEnumerable first, IEnumerable yield return iter.Current; if (i < index) - throw new ArgumentOutOfRangeException(nameof(index), "Insertion index is greater than the length of the first sequence."); + throw new ArgumentOutOfRangeException(nameof(index), "Insertion index is greater than the length of the first sequence."); foreach (var item in second) yield return item; diff --git a/MoreLinq/Interleave.cs b/MoreLinq/Interleave.cs index 47ec2af7e..9912eef20 100644 --- a/MoreLinq/Interleave.cs +++ b/MoreLinq/Interleave.cs @@ -50,9 +50,9 @@ public static IEnumerable Interleave(this IEnumerable sequence, params if (otherSequences.Any(s => s == null)) throw new ArgumentNullException(nameof(otherSequences), "One or more sequences passed to Interleave was null."); - return _(otherSequences.Prepend(sequence)); + return Impl(otherSequences.Prepend(sequence)); - static IEnumerable _(IEnumerable> sequences) + static IEnumerable Impl(IEnumerable> sequences) { var enumerators = new LinkedList>(); @@ -64,7 +64,7 @@ static IEnumerable _(IEnumerable> sequences) { var enumerator = sequence.GetEnumerator(); - enumerators.AddLast(enumerator); + _ = enumerators.AddLast(enumerator); if (enumerator.MoveNext()) { yield return enumerator.Current; @@ -72,7 +72,7 @@ static IEnumerable _(IEnumerable> sequences) else // Dispose and remove empty sequence { enumerator.Dispose(); - enumerators.Remove(enumerator); + _ = enumerators.Remove(enumerator); } } diff --git a/MoreLinq/Lookup.cs b/MoreLinq/Lookup.cs index bf31984e1..e9dfd11d9 100644 --- a/MoreLinq/Lookup.cs +++ b/MoreLinq/Lookup.cs @@ -25,6 +25,8 @@ #endregion #pragma warning disable IDE0040 // Add accessibility modifiers +#pragma warning disable IDE0032 // Use auto property +#pragma warning disable IDE0017 // Simplify object initialization namespace MoreLinq { diff --git a/MoreLinq/MaxBy.cs b/MoreLinq/MaxBy.cs index 0ffe2f5de..919c98fdd 100644 --- a/MoreLinq/MaxBy.cs +++ b/MoreLinq/MaxBy.cs @@ -215,7 +215,7 @@ public static IExtremaEnumerable MaxBy(this IEnumerable< if (selector == null) throw new ArgumentNullException(nameof(selector)); comparer ??= Comparer.Default; - return new ExtremaEnumerable(source, selector, (x, y) => comparer.Compare(x, y)); + return new ExtremaEnumerable(source, selector, comparer.Compare); } sealed class ExtremaEnumerable : IExtremaEnumerable @@ -279,8 +279,8 @@ sealed class LastExtrema : Extrema?, T> public override void Add(ref Queue? store, int? limit, T item) { - if (limit is {} n && store is {} queue && queue.Count == n) - queue.Dequeue(); + if (limit is { } n && store is { } queue && queue.Count == n) + _ = queue.Dequeue(); (store ??= new Queue()).Enqueue(item); } } @@ -348,6 +348,8 @@ IEnumerable Extrema() case 0: extrema.Add(ref store, limit, item); break; + default: + break; } } diff --git a/MoreLinq/Move.cs b/MoreLinq/Move.cs index ea6aaa808..43e38d2d7 100644 --- a/MoreLinq/Move.cs +++ b/MoreLinq/Move.cs @@ -63,7 +63,7 @@ public static IEnumerable Move(this IEnumerable source, int fromIndex, IEnumerable _(int bufferStartIndex, int bufferSize, int bufferYieldIndex) { - bool hasMore = true; + var hasMore = true; bool MoveNext(IEnumerator e) => hasMore && (hasMore = e.MoveNext()); using var e = source.GetEnumerator(); diff --git a/MoreLinq/PadStart.cs b/MoreLinq/PadStart.cs index c561c678f..5fdfd7a55 100644 --- a/MoreLinq/PadStart.cs +++ b/MoreLinq/PadStart.cs @@ -119,42 +119,42 @@ static IEnumerable PadStartImpl(IEnumerable source, int width, T? padding, Func? paddingSelector) { return - source.TryGetCollectionCount() is {} collectionCount + source.TryGetCollectionCount() is { } collectionCount ? collectionCount >= width ? source : Enumerable.Range(0, width - collectionCount) .Select(i => paddingSelector != null ? paddingSelector(i) : padding!) .Concat(source) : _(); IEnumerable _() + { + var array = new T[width]; + var count = 0; + + using (var e = source.GetEnumerator()) { - var array = new T[width]; - var count = 0; + for (; count < width && e.MoveNext(); count++) + array[count] = e.Current; - using (var e = source.GetEnumerator()) + if (count == width) { - for (; count < width && e.MoveNext(); count++) - array[count] = e.Current; - - if (count == width) - { - for (var i = 0; i < count; i++) - yield return array[i]; + for (var i = 0; i < count; i++) + yield return array[i]; - while (e.MoveNext()) - yield return e.Current; + while (e.MoveNext()) + yield return e.Current; - yield break; - } + yield break; } + } - var len = width - count; + var len = width - count; - for (var i = 0; i < len; i++) - yield return paddingSelector != null ? paddingSelector(i) : padding!; + for (var i = 0; i < len; i++) + yield return paddingSelector != null ? paddingSelector(i) : padding!; - for (var i = 0; i < count; i++) - yield return array[i]; - } + for (var i = 0; i < count; i++) + yield return array[i]; + } } } } diff --git a/MoreLinq/PartialSort.cs b/MoreLinq/PartialSort.cs index ecf8b1aec..51f9e23aa 100644 --- a/MoreLinq/PartialSort.cs +++ b/MoreLinq/PartialSort.cs @@ -243,7 +243,7 @@ static IEnumerable PartialSortByImpl( if (keys != null) { var key = Assume.NotNull(keySelector)(item); - if (Insert(keys, key, keyComparer) is {} i) + if (Insert(keys, key, keyComparer) is { } i) { if (top.Count == count) top.RemoveAt(count - 1); diff --git a/MoreLinq/PendNode.cs b/MoreLinq/PendNode.cs index 65f53e20a..2bf363863 100644 --- a/MoreLinq/PendNode.cs +++ b/MoreLinq/PendNode.cs @@ -101,7 +101,7 @@ public IEnumerator GetEnumerator() } } - var source = (Source) current; + var source = (Source)current; foreach (var item in source.Value) yield return item; @@ -111,7 +111,7 @@ public IEnumerator GetEnumerator() if (i == 4) { yield return concat4!; i--; } if (i == 3) { yield return concat3!; i--; } if (i == 2) { yield return concat2!; i--; } - if (i == 1) { yield return concat1!; i--; } + if (i == 1) { yield return concat1!; } yield break; } diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs index e60316179..d603f58f7 100644 --- a/MoreLinq/Permutations.cs +++ b/MoreLinq/Permutations.cs @@ -99,7 +99,7 @@ public void Reset() _generatorIterator = _generator.GetEnumerator(); // we must advance the nested loop iterator to the initial element, // this ensures that we only ever produce N!-1 calls to NextPermutation() - _generatorIterator.MoveNext(); + _ = _generatorIterator.MoveNext(); _hasMoreResults = true; // there's always at least one permutation: the original set itself } diff --git a/MoreLinq/Random.cs b/MoreLinq/Random.cs index fd4c88757..9999b8e67 100644 --- a/MoreLinq/Random.cs +++ b/MoreLinq/Random.cs @@ -161,12 +161,7 @@ public static IEnumerable Random(int minValue, int maxValue) public static IEnumerable Random(Random rand, int minValue, int maxValue) { if (rand == null) throw new ArgumentNullException(nameof(rand)); - - if (minValue > maxValue) - { - throw new ArgumentOutOfRangeException(nameof(minValue), - $"The argument minValue ({minValue}) is greater than maxValue ({maxValue})"); - } + if (minValue > maxValue) throw new ArgumentOutOfRangeException(nameof(minValue), $"The argument minValue ({minValue}) is greater than maxValue ({maxValue})"); return RandomImpl(rand, r => r.Next(minValue, maxValue)); } diff --git a/MoreLinq/Reactive/Subject.cs b/MoreLinq/Reactive/Subject.cs index bef962abb..145282cf0 100644 --- a/MoreLinq/Reactive/Subject.cs +++ b/MoreLinq/Reactive/Subject.cs @@ -109,7 +109,7 @@ public void OnNext(T value) // Remove any observers that were marked for deletion during // iteration. - observers.RemoveAll(o => o == null); + _ = observers.RemoveAll(o => o == null); } } diff --git a/MoreLinq/ReverseComparer.cs b/MoreLinq/ReverseComparer.cs index 00086383d..63fbf527f 100644 --- a/MoreLinq/ReverseComparer.cs +++ b/MoreLinq/ReverseComparer.cs @@ -23,10 +23,8 @@ sealed class ReverseComparer : IComparer { readonly IComparer _underlying; - public ReverseComparer(IComparer? underlying) - { + public ReverseComparer(IComparer? underlying) => _underlying = underlying ?? Comparer.Default; - } public int Compare #if NETCOREAPP3_1_OR_GREATER diff --git a/MoreLinq/RunLengthEncode.cs b/MoreLinq/RunLengthEncode.cs index 566e97a8a..232c38e37 100644 --- a/MoreLinq/RunLengthEncode.cs +++ b/MoreLinq/RunLengthEncode.cs @@ -47,8 +47,7 @@ public static IEnumerable> RunLengthEncode(this IEnumera public static IEnumerable> RunLengthEncode(this IEnumerable sequence, IEqualityComparer? comparer) { - if (sequence == null) - throw new ArgumentNullException(nameof(sequence)); + if (sequence == null) throw new ArgumentNullException(nameof(sequence)); return _(comparer ?? EqualityComparer.Default); diff --git a/MoreLinq/Segment.cs b/MoreLinq/Segment.cs index 72de5fc4b..788aa3ae7 100644 --- a/MoreLinq/Segment.cs +++ b/MoreLinq/Segment.cs @@ -94,8 +94,8 @@ public static IEnumerable> Segment(this IEnumerable source, if (newSegmentPredicate(current, previous, index)) { - yield return segment; // yield the completed segment - segment = new List { current }; // start a new segment + yield return segment; // yield the completed segment + segment = new List { current }; // start a new segment } else // not a new segment, append and continue { diff --git a/MoreLinq/SequenceException.cs b/MoreLinq/SequenceException.cs index 65a025c92..8b9a3c930 100644 --- a/MoreLinq/SequenceException.cs +++ b/MoreLinq/SequenceException.cs @@ -27,7 +27,7 @@ namespace MoreLinq /// #if !NO_EXCEPTION_SERIALIZATION - [ Serializable ] + [Serializable] #endif public class SequenceException : Exception { @@ -38,7 +38,7 @@ public class SequenceException : Exception /// public SequenceException() : - this(null) {} + this(null) { } /// /// Initializes a new instance of the class @@ -69,7 +69,7 @@ public SequenceException(string? message, Exception? innerException) : /// The contextual information about the source or destination. protected SequenceException(SerializationInfo info, StreamingContext context) : - base(info, context) {} + base(info, context) { } #endif } } diff --git a/MoreLinq/SkipLast.cs b/MoreLinq/SkipLast.cs index cfee629b3..e97a29c37 100644 --- a/MoreLinq/SkipLast.cs +++ b/MoreLinq/SkipLast.cs @@ -37,15 +37,11 @@ public static IEnumerable SkipLast(this IEnumerable source, int count) { if (source == null) throw new ArgumentNullException(nameof(source)); - if (count < 1) - return source; - - return - source.TryGetCollectionCount() is {} collectionCount - ? source.Take(collectionCount - count) - : source.CountDown(count, (e, cd) => (Element: e, Countdown: cd )) - .TakeWhile(e => e.Countdown == null) - .Select(e => e.Element); + return count < 1 ? source + : source.TryGetCollectionCount() is { } collectionCount ? source.Take(collectionCount - count) + : source.CountDown(count, (e, cd) => (Element: e, Countdown: cd)) + .TakeWhile(e => e.Countdown == null) + .Select(e => e.Element); } } } diff --git a/MoreLinq/StartsWith.cs b/MoreLinq/StartsWith.cs index a15c17479..bdfcc17e7 100644 --- a/MoreLinq/StartsWith.cs +++ b/MoreLinq/StartsWith.cs @@ -73,8 +73,8 @@ public static bool StartsWith(this IEnumerable first, IEnumerable secon if (first == null) throw new ArgumentNullException(nameof(first)); if (second == null) throw new ArgumentNullException(nameof(second)); - if (first.TryGetCollectionCount() is {} firstCount && - second.TryGetCollectionCount() is {} secondCount && + if (first.TryGetCollectionCount() is { } firstCount && + second.TryGetCollectionCount() is { } secondCount && secondCount > firstCount) { return false; diff --git a/MoreLinq/Subsets.cs b/MoreLinq/Subsets.cs index 1443f97f1..65054f529 100644 --- a/MoreLinq/Subsets.cs +++ b/MoreLinq/Subsets.cs @@ -191,7 +191,7 @@ public bool MoveNext() ExtractSubset(); - _continue = (_indices[0] != _z); + _continue = _indices[0] != _z; return true; } diff --git a/MoreLinq/TakeLast.cs b/MoreLinq/TakeLast.cs index dba1d1ebb..0512342dd 100644 --- a/MoreLinq/TakeLast.cs +++ b/MoreLinq/TakeLast.cs @@ -50,15 +50,12 @@ public static IEnumerable TakeLast(this IEnumerable s { if (source == null) throw new ArgumentNullException(nameof(source)); - if (count < 1) - return Enumerable.Empty(); - - return - source.TryGetCollectionCount() is {} collectionCount - ? source.Slice(Math.Max(0, collectionCount - count), int.MaxValue) - : source.CountDown(count, (e, cd) => (Element: e, Countdown: cd)) - .SkipWhile(e => e.Countdown == null) - .Select(e => e.Element); + return count < 1 ? Enumerable.Empty() + : source.TryGetCollectionCount() is { } collectionCount + ? source.Slice(Math.Max(0, collectionCount - count), int.MaxValue) + : source.CountDown(count, (e, cd) => (Element: e, Countdown: cd)) + .SkipWhile(e => e.Countdown == null) + .Select(e => e.Element); } } } diff --git a/MoreLinq/ToArrayByIndex.cs b/MoreLinq/ToArrayByIndex.cs index 5fa513ab5..ce7c5917f 100644 --- a/MoreLinq/ToArrayByIndex.cs +++ b/MoreLinq/ToArrayByIndex.cs @@ -121,12 +121,14 @@ public static TResult[] ToArrayByIndex(this IEnumerable source, if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); var lastIndex = -1; - var indexed = (List>?) null; + var indexed = (List>?)null; List> Indexed() => indexed ??= new List>(); foreach (var e in source) { +#pragma warning disable IDE0010 // Add missing cases (false negative) switch (indexSelector(e)) +#pragma warning restore IDE0010 // Add missing cases { case < 0: #pragma warning disable CA2201 // Do not raise reserved exception types diff --git a/MoreLinq/ToDataTable.cs b/MoreLinq/ToDataTable.cs index 2342ae0f1..af24eebb0 100644 --- a/MoreLinq/ToDataTable.cs +++ b/MoreLinq/ToDataTable.cs @@ -191,8 +191,8 @@ static MemberInfo[] BuildOrBindSchema(DataTable table, MemberInfo[] members) var schemas = from m in members let type = m.MemberType == MemberTypes.Property - ? ((PropertyInfo) m).PropertyType - : ((FieldInfo) m).FieldType + ? ((PropertyInfo)m).PropertyType + : ((FieldInfo)m).FieldType select new { Member = m, diff --git a/MoreLinq/ToDelimitedString.cs b/MoreLinq/ToDelimitedString.cs index c77d7eeb2..18c88e063 100644 --- a/MoreLinq/ToDelimitedString.cs +++ b/MoreLinq/ToDelimitedString.cs @@ -57,8 +57,9 @@ static string ToDelimitedStringImpl(IEnumerable source, string delimiter, foreach (var value in source) { - if (i++ > 0) sb.Append(delimiter); - append(sb, value); + if (i++ > 0) + _ = sb.Append(delimiter); + _ = append(sb, value); } return sb.ToString(); diff --git a/MoreLinq/Trace.cs b/MoreLinq/Trace.cs index d7917a8c6..e47a24227 100644 --- a/MoreLinq/Trace.cs +++ b/MoreLinq/Trace.cs @@ -37,7 +37,7 @@ static partial class MoreEnumerable public static IEnumerable Trace(this IEnumerable source) { - return Trace(source, (string?) null); + return Trace(source, (string?)null); } /// diff --git a/MoreLinq/Transpose.cs b/MoreLinq/Transpose.cs index 54ff80c14..eb1a151bd 100644 --- a/MoreLinq/Transpose.cs +++ b/MoreLinq/Transpose.cs @@ -58,7 +58,9 @@ public static IEnumerable> Transpose(this IEnumerable> _() { +#pragma warning disable IDE0007 // Use implicit type (false positive) IEnumerator?[] enumerators = source.Select(e => e.GetEnumerator()).Acquire(); +#pragma warning restore IDE0007 // Use implicit type try { diff --git a/bld/ExtensionsGenerator/Program.cs b/bld/ExtensionsGenerator/Program.cs index 03b85ab08..aa68f4fa4 100644 --- a/bld/ExtensionsGenerator/Program.cs +++ b/bld/ExtensionsGenerator/Program.cs @@ -117,7 +117,7 @@ static Func var abbreviatedTypeNodes = Enumerable .Range(0, 26) - .Select(a => (char) ('a' + a)) + .Select(a => (char)('a' + a)) .Select(ch => new SimpleTypeKey(ch.ToString())) .ToArray(); @@ -243,7 +243,7 @@ into e var indent2 = indent + indent; var indent3 = indent2 + indent; - var baseImports = new [] + var baseImports = new[] { "System", "System.CodeDom.Compiler", @@ -403,7 +403,7 @@ protected static int Compare(IEnumerable a, IEnumerable b) => sealed class SimpleTypeKey : TypeKey { - public SimpleTypeKey(string name) : base(name) {} + public SimpleTypeKey(string name) : base(name) { } public override string ToString() => Name; public override ImmutableList Parameters => ImmutableList.Empty; } @@ -411,7 +411,7 @@ public SimpleTypeKey(string name) : base(name) {} abstract class ParameterizedTypeKey : TypeKey { protected ParameterizedTypeKey(string name, TypeKey parameter) : - this(name, ImmutableList.Create(parameter)) {} + this(name, ImmutableList.Create(parameter)) { } protected ParameterizedTypeKey(string name, ImmutableList parameters) : base(name) => Parameters = parameters; @@ -422,7 +422,7 @@ protected ParameterizedTypeKey(string name, ImmutableList parameters) : sealed class GenericTypeKey : ParameterizedTypeKey { public GenericTypeKey(string name, ImmutableList parameters) : - base(name, parameters) {} + base(name, parameters) { } public override string ToString() => Name + "<" + string.Join(", ", Parameters) + ">"; @@ -430,14 +430,14 @@ public override string ToString() => sealed class NullableTypeKey : ParameterizedTypeKey { - public NullableTypeKey(TypeKey underlying) : base("?", underlying) {} + public NullableTypeKey(TypeKey underlying) : base("?", underlying) { } public override string ToString() => Parameters.Single() + "?"; } sealed class TupleTypeKey : ParameterizedTypeKey { public TupleTypeKey(ImmutableList parameters) : - base("()", parameters) {} + base("()", parameters) { } public override string ToString() => "(" + string.Join(", ", Parameters) + ")"; @@ -460,9 +460,12 @@ protected override int CompareParameters(TypeKey other) { if (Ranks.Count.CompareTo(a.Ranks.Count) is var rlc and not 0) return rlc; + if (Ranks.Zip(a.Ranks, (us, them) => (Us: us, Them: them)) .Aggregate(0, (c, r) => c == 0 ? r.Us.CompareTo(r.Them) : c) is var rc and not 0) + { return rc; + } } return base.CompareParameters(other); From 952186981a667e9d1075bb5b5b451aa1199b691a Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 26 Jan 2023 18:19:22 +0100 Subject: [PATCH 048/157] List-like union struct to save allocation + virtual dispatch --- MoreLinq/AggregateRight.cs | 2 +- MoreLinq/CountDown.cs | 2 +- MoreLinq/ListLike.cs | 58 ++++++++++++++++++++++---------------- MoreLinq/ScanRight.cs | 2 +- 4 files changed, 36 insertions(+), 28 deletions(-) diff --git a/MoreLinq/AggregateRight.cs b/MoreLinq/AggregateRight.cs index 92bad8f54..cd122f312 100644 --- a/MoreLinq/AggregateRight.cs +++ b/MoreLinq/AggregateRight.cs @@ -122,7 +122,7 @@ public static TResult AggregateRight(this IEnumer return resultSelector(source.AggregateRight(seed, func)); } - static TResult AggregateRightImpl(IListLike list, TResult accumulator, Func func, int i) + static TResult AggregateRightImpl(ListLike list, TResult accumulator, Func func, int i) { while (i-- > 0) { diff --git a/MoreLinq/CountDown.cs b/MoreLinq/CountDown.cs index f5cb867f0..3df352ffd 100644 --- a/MoreLinq/CountDown.cs +++ b/MoreLinq/CountDown.cs @@ -63,7 +63,7 @@ public static IEnumerable CountDown(this IEnumerable sou ? IterateCollection(collectionCount) : IterateSequence(); - IEnumerable IterateList(IListLike list) + IEnumerable IterateList(ListLike list) { var listCount = list.Count; var countdown = Math.Min(count, listCount); diff --git a/MoreLinq/ListLike.cs b/MoreLinq/ListLike.cs index d0d4c44de..0773791b4 100644 --- a/MoreLinq/ListLike.cs +++ b/MoreLinq/ListLike.cs @@ -22,43 +22,51 @@ namespace MoreLinq using System.Linq; /// - /// Represents an list-like (indexable) data structure. + /// Represents a union over list types implementing either + /// or , allowing + /// both to be treated the same. /// - interface IListLike + readonly struct ListLike { - int Count { get; } - T this[int index] { get; } + readonly IList? _rw; + readonly IReadOnlyList? _rx; + + public ListLike(IList list) + { + _rw = list ?? throw new ArgumentNullException(nameof(list)); + _rx = null; + } + + public ListLike(IReadOnlyList list) + { + _rw = null; + _rx = list ?? throw new ArgumentNullException(nameof(list)); + } + + public int Count => _rw?.Count ?? _rx?.Count ?? 0; + + public T this[int index] => _rw is { } rw ? rw[index] + : _rx is { } rx ? rx[index] + : throw new ArgumentOutOfRangeException(nameof(index)); } static class ListLike { - public static IListLike ToListLike(this IEnumerable source) - => source.TryAsListLike() ?? new List(source.ToList()); + public static ListLike AsListLike(this List list) => new((IList)list); + public static ListLike AsListLike(this IList list) => new(list); + public static ListLike AsListLike(this IReadOnlyList list) => new(list); - public static IListLike? TryAsListLike(this IEnumerable source) => + public static ListLike ToListLike(this IEnumerable source) + => source.TryAsListLike() ?? source.ToList().AsListLike(); + + public static ListLike? TryAsListLike(this IEnumerable source) => source switch { null => throw new ArgumentNullException(nameof(source)), - IList list => new List(list), - IReadOnlyList list => new ReadOnlyList(list), + IList list => list.AsListLike(), + IReadOnlyList list => list.AsListLike(), _ => null }; - - sealed class List : IListLike - { - readonly IList _list; - public List(IList list) => _list = list ?? throw new ArgumentNullException(nameof(list)); - public int Count => _list.Count; - public T this[int index] => _list[index]; - } - - sealed class ReadOnlyList : IListLike - { - readonly IReadOnlyList _list; - public ReadOnlyList(IReadOnlyList list) => _list = list ?? throw new ArgumentNullException(nameof(list)); - public int Count => _list.Count; - public T this[int index] => _list[index]; - } } } diff --git a/MoreLinq/ScanRight.cs b/MoreLinq/ScanRight.cs index 8afefcece..1ddb828de 100644 --- a/MoreLinq/ScanRight.cs +++ b/MoreLinq/ScanRight.cs @@ -84,7 +84,7 @@ public static IEnumerable ScanRight(this IEnu return ScanRightImpl(source, func, list => (seed, list.Count)); } - static IEnumerable ScanRightImpl(IEnumerable source, Func func, Func, (TResult Seed, int Count)?> seeder) + static IEnumerable ScanRightImpl(IEnumerable source, Func func, Func, (TResult Seed, int Count)?> seeder) { var list = source.ToListLike(); From c8004ac0df28c61d72625974ce813e36070e41e9 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 26 Jan 2023 18:38:44 +0100 Subject: [PATCH 049/157] Fix collection-optimized paths to be at iteration-time This is a merge of PR #946 that fixes #943. --- MoreLinq.Test/AssertCountTest.cs | 18 +++++---- MoreLinq.Test/CountDownTest.cs | 9 +++++ MoreLinq.Test/FallbackIfEmptyTest.cs | 46 +++++++++++------------ MoreLinq.Test/PadStartTest.cs | 8 ++++ MoreLinq.Test/SkipLastTest.cs | 10 +++++ MoreLinq.Test/TakeLastTest.cs | 9 +++++ MoreLinq/AssertCount.cs | 13 ++++--- MoreLinq/CollectionLike.cs | 52 ++++++++++++++++++++++++++ MoreLinq/CountDown.cs | 9 +++-- MoreLinq/CountMethods.cs | 8 ++-- MoreLinq/EndsWith.cs | 4 +- MoreLinq/Experimental/TrySingle.cs | 6 +-- MoreLinq/FallbackIfEmpty.cs | 24 +++++------- MoreLinq/MoreEnumerable.cs | 6 +-- MoreLinq/PadStart.cs | 56 +++++++++++++++------------- MoreLinq/SkipLast.cs | 1 - MoreLinq/StartsWith.cs | 4 +- MoreLinq/TakeLast.cs | 8 ++-- 18 files changed, 189 insertions(+), 102 deletions(-) create mode 100644 MoreLinq/CollectionLike.cs diff --git a/MoreLinq.Test/AssertCountTest.cs b/MoreLinq.Test/AssertCountTest.cs index 73aee530f..b8dfe839d 100644 --- a/MoreLinq.Test/AssertCountTest.cs +++ b/MoreLinq.Test/AssertCountTest.cs @@ -18,6 +18,7 @@ namespace MoreLinq.Test { using System; + using System.Collections.Generic; using NUnit.Framework; [TestFixture] @@ -113,13 +114,6 @@ public void AssertCountWithCollectionIsLazy() _ = new BreakingCollection(new int[5]).AssertCount(0); } - [Test] - public void AssertCountWithMatchingCollectionCount() - { - var xs = new[] { 123, 456, 789 }; - Assert.That(xs, Is.SameAs(xs.AssertCount(3))); - } - [TestCase(3, 2, "Sequence contains too many elements when exactly 2 were expected.")] [TestCase(3, 4, "Sequence contains too few elements when exactly 4 were expected.")] public void AssertCountWithMismatchingCollectionCount(int sourceCount, int count, string message) @@ -135,5 +129,15 @@ public void AssertCountWithReadOnlyCollectionIsLazy() { _ = new BreakingReadOnlyCollection(5).AssertCount(0); } + + [Test] + public void AssertCountUsesCollectionCountAtIterationTime() + { + var stack = new Stack(Enumerable.Range(1, 3)); + var result = stack.AssertCount(4); + stack.Push(4); + result.Consume(); + Assert.Pass(); + } } } diff --git a/MoreLinq.Test/CountDownTest.cs b/MoreLinq.Test/CountDownTest.cs index 5d047e177..b7c635667 100644 --- a/MoreLinq.Test/CountDownTest.cs +++ b/MoreLinq.Test/CountDownTest.cs @@ -211,5 +211,14 @@ public ReadOnlyCollection(ICollection collection, protected override IEnumerable Items => _collection; } } + + [Test] + public void UsesCollectionCountAtIterationTime() + { + var stack = new Stack(Enumerable.Range(1, 3)); + var result = stack.CountDown(2, (_, cd) => cd); + stack.Push(4); + result.AssertSequenceEqual(null, null, 1, 0); + } } } diff --git a/MoreLinq.Test/FallbackIfEmptyTest.cs b/MoreLinq.Test/FallbackIfEmptyTest.cs index 65ccfc788..451484606 100644 --- a/MoreLinq.Test/FallbackIfEmptyTest.cs +++ b/MoreLinq.Test/FallbackIfEmptyTest.cs @@ -17,6 +17,7 @@ namespace MoreLinq.Test { + using System.Collections.Generic; using NUnit.Framework; [TestFixture] @@ -36,31 +37,6 @@ public void FallbackIfEmptyWithEmptySequence() // ReSharper restore PossibleMultipleEnumeration } - [TestCase(SourceKind.BreakingCollection)] - [TestCase(SourceKind.BreakingReadOnlyCollection)] - public void FallbackIfEmptyPreservesSourceCollectionIfPossible(SourceKind sourceKind) - { - var source = new[] { 1 }.ToSourceKind(sourceKind); - // ReSharper disable PossibleMultipleEnumeration - Assert.That(source.FallbackIfEmpty(12), Is.SameAs(source)); - Assert.That(source.FallbackIfEmpty(12, 23), Is.SameAs(source)); - Assert.That(source.FallbackIfEmpty(12, 23, 34), Is.SameAs(source)); - Assert.That(source.FallbackIfEmpty(12, 23, 34, 45), Is.SameAs(source)); - Assert.That(source.FallbackIfEmpty(12, 23, 34, 45, 56), Is.SameAs(source)); - Assert.That(source.FallbackIfEmpty(12, 23, 34, 45, 56, 67), Is.SameAs(source)); - // ReSharper restore PossibleMultipleEnumeration - } - - [TestCase(SourceKind.BreakingCollection)] - [TestCase(SourceKind.BreakingReadOnlyCollection)] - public void FallbackIfEmptyPreservesFallbackCollectionIfPossible(SourceKind sourceKind) - { - var source = new int[0].ToSourceKind(sourceKind); - var fallback = new[] { 1 }; - Assert.That(source.FallbackIfEmpty(fallback), Is.SameAs(fallback)); - Assert.That(source.FallbackIfEmpty(fallback.AsEnumerable()), Is.SameAs(fallback)); - } - [Test] public void FallbackIfEmptyWithEmptyNullableSequence() { @@ -68,5 +44,25 @@ public void FallbackIfEmptyWithEmptyNullableSequence() var fallback = (int?)null; source.FallbackIfEmpty(fallback).AssertSequenceEqual(fallback); } + + [Test] + public void FallbackUsesCollectionCountAtIterationTime() + { + var source = new List(); + + var results = new[] + { + source.FallbackIfEmpty(-1), + source.FallbackIfEmpty(-1, -2), + source.FallbackIfEmpty(-1, -2, -3), + source.FallbackIfEmpty(-1, -2, -3, -4), + source.FallbackIfEmpty(-1, -2, -3, -4, -5), + }; + + source.Add(123); + + foreach (var result in results) + result.AssertSequenceEqual(123); + } } } diff --git a/MoreLinq.Test/PadStartTest.cs b/MoreLinq.Test/PadStartTest.cs index 7e504f5f4..78d45ef4d 100644 --- a/MoreLinq.Test/PadStartTest.cs +++ b/MoreLinq.Test/PadStartTest.cs @@ -133,6 +133,14 @@ public void ReferenceTypeElements(ICollection source, int width, IEnumer } } + [Test] + public void PadStartUsesCollectionCountAtIterationTime() + { + var queue = new Queue(Enumerable.Range(1, 3)); + var result = queue.PadStart(4, -1); + queue.Enqueue(4); + result.AssertSequenceEqual(1, 2, 3, 4); + } static void AssertEqual(ICollection input, Func, IEnumerable> op, IEnumerable expected) { diff --git a/MoreLinq.Test/SkipLastTest.cs b/MoreLinq.Test/SkipLastTest.cs index dfdbad739..df7b19680 100644 --- a/MoreLinq.Test/SkipLastTest.cs +++ b/MoreLinq.Test/SkipLastTest.cs @@ -17,6 +17,7 @@ namespace MoreLinq.Test { + using System.Collections.Generic; using NUnit.Framework; [TestFixture] @@ -56,5 +57,14 @@ public void SkipLastIsLazy() { _ = new BreakingSequence().SkipLast(1); } + + [Test] + public void SkipLastUsesCollectionCountAtIterationTime() + { + var list = new List { 1, 2, 3, 4 }; + var result = list.SkipLast(2); + list.Add(5); + result.AssertSequenceEqual(1, 2, 3); + } } } diff --git a/MoreLinq.Test/TakeLastTest.cs b/MoreLinq.Test/TakeLastTest.cs index fdbd8f923..5779f4cfc 100644 --- a/MoreLinq.Test/TakeLastTest.cs +++ b/MoreLinq.Test/TakeLastTest.cs @@ -70,6 +70,15 @@ public void TakeLastOptimizedForCollections(SourceKind sourceKind) sequence.TakeLast(3).AssertSequenceEqual(8, 9, 10); } + [Test] + public void TakeLastUsesCollectionCountAtIterationTime() + { + var list = new List { 1, 2, 3, 4 }; + var result = list.TakeLast(3); + list.Add(5); + result.AssertSequenceEqual(3, 4, 5); + } + static void AssertTakeLast(ICollection input, int count, Action> action) { // Test that the behaviour does not change whether a collection diff --git a/MoreLinq/AssertCount.cs b/MoreLinq/AssertCount.cs index 916400abf..0273bf060 100644 --- a/MoreLinq/AssertCount.cs +++ b/MoreLinq/AssertCount.cs @@ -86,13 +86,14 @@ static IEnumerable AssertCountImpl(IEnumerable source if (count < 0) throw new ArgumentOutOfRangeException(nameof(count)); if (errorSelector == null) throw new ArgumentNullException(nameof(errorSelector)); - return - source.TryGetCollectionCount() is { } collectionCount - ? collectionCount == count - ? source - : From(() => throw errorSelector(collectionCount.CompareTo(count), count)) - : _(); IEnumerable _() + return _(); IEnumerable _() { + if (source.TryAsCollectionLike() is { Count: var collectionCount } + && collectionCount.CompareTo(count) is var comparison && comparison != 0) + { + throw errorSelector(comparison, count); + } + var iterations = 0; foreach (var element in source) { diff --git a/MoreLinq/CollectionLike.cs b/MoreLinq/CollectionLike.cs new file mode 100644 index 000000000..16286cdb3 --- /dev/null +++ b/MoreLinq/CollectionLike.cs @@ -0,0 +1,52 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2023 Atif Aziz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq +{ + using System; + using System.Collections.Generic; + using System.Linq; + + /// + /// Represents a union over list types implementing either or , + /// allowing both to be treated the same. + /// + + readonly struct CollectionLike + { + readonly ICollection? _rw; + readonly IReadOnlyCollection? _rx; + + public CollectionLike(ICollection collection) + { + _rw = collection ?? throw new ArgumentNullException(nameof(collection)); + _rx = null; + } + + public CollectionLike(IReadOnlyCollection collection) + { + _rw = null; + _rx = collection ?? throw new ArgumentNullException(nameof(collection)); + } + + public int Count => _rw?.Count ?? _rx?.Count ?? 0; + + public IEnumerator GetEnumerator() => + _rw?.GetEnumerator() ?? _rx?.GetEnumerator() ?? Enumerable.Empty().GetEnumerator(); + } +} diff --git a/MoreLinq/CountDown.cs b/MoreLinq/CountDown.cs index 3df352ffd..53310e79a 100644 --- a/MoreLinq/CountDown.cs +++ b/MoreLinq/CountDown.cs @@ -59,8 +59,8 @@ public static IEnumerable CountDown(this IEnumerable sou return source.TryAsListLike() is { } listLike ? IterateList(listLike) - : source.TryGetCollectionCount() is { } collectionCount - ? IterateCollection(collectionCount) + : source.TryAsCollectionLike() is { } collectionLike + ? IterateCollection(collectionLike) : IterateSequence(); IEnumerable IterateList(ListLike list) @@ -72,9 +72,10 @@ IEnumerable IterateList(ListLike list) yield return resultSelector(list[i], listCount - i <= count ? --countdown : null); } - IEnumerable IterateCollection(int i) + IEnumerable IterateCollection(CollectionLike collection) { - foreach (var item in source) + var i = collection.Count; + foreach (var item in collection) yield return resultSelector(item, i-- <= count ? i : null); } diff --git a/MoreLinq/CountMethods.cs b/MoreLinq/CountMethods.cs index c2eef6abb..9e9818ff2 100644 --- a/MoreLinq/CountMethods.cs +++ b/MoreLinq/CountMethods.cs @@ -136,7 +136,7 @@ static bool QuantityIterator(IEnumerable source, int limit, int min, int m { if (source == null) throw new ArgumentNullException(nameof(source)); - var count = source.TryGetCollectionCount() ?? source.CountUpTo(limit); + var count = source.TryAsCollectionLike()?.Count ?? source.CountUpTo(limit); return count >= min && count <= max; } @@ -167,11 +167,11 @@ public static int CompareCount(this IEnumerable first, if (first == null) throw new ArgumentNullException(nameof(first)); if (second == null) throw new ArgumentNullException(nameof(second)); - if (first.TryGetCollectionCount() is { } firstCount) + if (first.TryAsCollectionLike() is { Count: var firstCount }) { - return firstCount.CompareTo(second.TryGetCollectionCount() ?? second.CountUpTo(firstCount + 1)); + return firstCount.CompareTo(second.TryAsCollectionLike()?.Count ?? second.CountUpTo(firstCount + 1)); } - else if (second.TryGetCollectionCount() is { } secondCount) + else if (second.TryAsCollectionLike() is { Count: var secondCount }) { return first.CountUpTo(secondCount + 1).CompareTo(secondCount); } diff --git a/MoreLinq/EndsWith.cs b/MoreLinq/EndsWith.cs index 3ff560bf5..d414a3dc0 100644 --- a/MoreLinq/EndsWith.cs +++ b/MoreLinq/EndsWith.cs @@ -75,8 +75,8 @@ public static bool EndsWith(this IEnumerable first, IEnumerable second, List secondList; #pragma warning disable IDE0075 // Simplify conditional expression (makes it worse) - return second.TryGetCollectionCount() is { } secondCount - ? first.TryGetCollectionCount() is { } firstCount && secondCount > firstCount + return second.TryAsCollectionLike() is { Count: var secondCount } + ? first.TryAsCollectionLike() is { Count: var firstCount } && secondCount > firstCount ? false : Impl(second, secondCount) : Impl(secondList = second.ToList(), secondList.Count); diff --git a/MoreLinq/Experimental/TrySingle.cs b/MoreLinq/Experimental/TrySingle.cs index 881e4ee75..06f2115c9 100644 --- a/MoreLinq/Experimental/TrySingle.cs +++ b/MoreLinq/Experimental/TrySingle.cs @@ -101,11 +101,11 @@ public static TResult TrySingle(this IEnumerable so if (source == null) throw new ArgumentNullException(nameof(source)); if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - switch (source.TryGetCollectionCount()) + switch (source.TryAsCollectionLike()) { - case 0: + case { Count: 0 }: return resultSelector(zero, default); - case 1: + case { Count: 1 }: { var item = source switch { diff --git a/MoreLinq/FallbackIfEmpty.cs b/MoreLinq/FallbackIfEmpty.cs index 2acbeae26..159a7de4f 100644 --- a/MoreLinq/FallbackIfEmpty.cs +++ b/MoreLinq/FallbackIfEmpty.cs @@ -161,14 +161,11 @@ static IEnumerable FallbackIfEmptyImpl(IEnumerable source, int? count, T? fallback1, T? fallback2, T? fallback3, T? fallback4, IEnumerable? fallback) { - return source.TryGetCollectionCount() is { } collectionCount - ? collectionCount == 0 ? Fallback() : source - : _(); - - IEnumerable _() + return _(); IEnumerable _() { - using (var e = source.GetEnumerator()) + if (source.TryAsCollectionLike() is null or { Count: > 0 }) { + using var e = source.GetEnumerator(); if (e.MoveNext()) { do { yield return e.Current; } @@ -177,15 +174,14 @@ IEnumerable _() } } - foreach (var item in Fallback()) - yield return item; - } - - IEnumerable Fallback() - { - return fallback ?? FallbackOnArgs(); + if (fallback is { } someFallback) + { + Debug.Assert(count is null); - IEnumerable FallbackOnArgs() + foreach (var item in someFallback) + yield return item; + } + else { Debug.Assert(count is >= 1 and <= 4); diff --git a/MoreLinq/MoreEnumerable.cs b/MoreLinq/MoreEnumerable.cs index b80983c3e..18aa05dd4 100644 --- a/MoreLinq/MoreEnumerable.cs +++ b/MoreLinq/MoreEnumerable.cs @@ -27,12 +27,12 @@ namespace MoreLinq public static partial class MoreEnumerable { - internal static int? TryGetCollectionCount(this IEnumerable source) => + internal static CollectionLike? TryAsCollectionLike(this IEnumerable source) => source switch { null => throw new ArgumentNullException(nameof(source)), - ICollection collection => collection.Count, - IReadOnlyCollection collection => collection.Count, + ICollection collection => new CollectionLike(collection), + IReadOnlyCollection collection => new CollectionLike(collection), _ => null }; diff --git a/MoreLinq/PadStart.cs b/MoreLinq/PadStart.cs index 5fdfd7a55..2979da6b3 100644 --- a/MoreLinq/PadStart.cs +++ b/MoreLinq/PadStart.cs @@ -19,7 +19,6 @@ namespace MoreLinq { using System; using System.Collections.Generic; - using System.Linq; static partial class MoreEnumerable { @@ -118,42 +117,47 @@ public static IEnumerable PadStart(this IEnumerable s static IEnumerable PadStartImpl(IEnumerable source, int width, T? padding, Func? paddingSelector) { - return - source.TryGetCollectionCount() is { } collectionCount - ? collectionCount >= width - ? source - : Enumerable.Range(0, width - collectionCount) - .Select(i => paddingSelector != null ? paddingSelector(i) : padding!) - .Concat(source) - : _(); IEnumerable _() + return _(); IEnumerable _() { - var array = new T[width]; - var count = 0; + if (source.TryAsCollectionLike() is { Count: var collectionCount } && collectionCount < width) + { + var paddingCount = width - collectionCount; + for (var i = 0; i < paddingCount; i++) + yield return paddingSelector is { } selector ? selector(i) : padding!; - using (var e = source.GetEnumerator()) + foreach (var item in source) + yield return item; + } + else { - for (; count < width && e.MoveNext(); count++) - array[count] = e.Current; + var array = new T[width]; + var count = 0; - if (count == width) + using (var e = source.GetEnumerator()) { - for (var i = 0; i < count; i++) - yield return array[i]; + for (; count < width && e.MoveNext(); count++) + array[count] = e.Current; + + if (count == width) + { + for (var i = 0; i < count; i++) + yield return array[i]; - while (e.MoveNext()) - yield return e.Current; + while (e.MoveNext()) + yield return e.Current; - yield break; + yield break; + } } - } - var len = width - count; + var len = width - count; - for (var i = 0; i < len; i++) - yield return paddingSelector != null ? paddingSelector(i) : padding!; + for (var i = 0; i < len; i++) + yield return paddingSelector != null ? paddingSelector(i) : padding!; - for (var i = 0; i < count; i++) - yield return array[i]; + for (var i = 0; i < count; i++) + yield return array[i]; + } } } } diff --git a/MoreLinq/SkipLast.cs b/MoreLinq/SkipLast.cs index e97a29c37..0483f3e74 100644 --- a/MoreLinq/SkipLast.cs +++ b/MoreLinq/SkipLast.cs @@ -38,7 +38,6 @@ public static IEnumerable SkipLast(this IEnumerable source, int count) if (source == null) throw new ArgumentNullException(nameof(source)); return count < 1 ? source - : source.TryGetCollectionCount() is { } collectionCount ? source.Take(collectionCount - count) : source.CountDown(count, (e, cd) => (Element: e, Countdown: cd)) .TakeWhile(e => e.Countdown == null) .Select(e => e.Element); diff --git a/MoreLinq/StartsWith.cs b/MoreLinq/StartsWith.cs index bdfcc17e7..f3b8ee5f0 100644 --- a/MoreLinq/StartsWith.cs +++ b/MoreLinq/StartsWith.cs @@ -73,8 +73,8 @@ public static bool StartsWith(this IEnumerable first, IEnumerable secon if (first == null) throw new ArgumentNullException(nameof(first)); if (second == null) throw new ArgumentNullException(nameof(second)); - if (first.TryGetCollectionCount() is { } firstCount && - second.TryGetCollectionCount() is { } secondCount && + if (first.TryAsCollectionLike() is { Count: var firstCount } && + second.TryAsCollectionLike() is { Count: var secondCount } && secondCount > firstCount) { return false; diff --git a/MoreLinq/TakeLast.cs b/MoreLinq/TakeLast.cs index 0512342dd..6619ff196 100644 --- a/MoreLinq/TakeLast.cs +++ b/MoreLinq/TakeLast.cs @@ -51,11 +51,9 @@ public static IEnumerable TakeLast(this IEnumerable s if (source == null) throw new ArgumentNullException(nameof(source)); return count < 1 ? Enumerable.Empty() - : source.TryGetCollectionCount() is { } collectionCount - ? source.Slice(Math.Max(0, collectionCount - count), int.MaxValue) - : source.CountDown(count, (e, cd) => (Element: e, Countdown: cd)) - .SkipWhile(e => e.Countdown == null) - .Select(e => e.Element); + : source.CountDown(count, (e, cd) => (Element: e, Countdown: cd)) + .SkipWhile(e => e.Countdown == null) + .Select(e => e.Element); } } } From 5e2a031453a1400989772870e6b4c2b9fa45ab69 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Fri, 27 Jan 2023 19:31:02 +0100 Subject: [PATCH 050/157] Rename read-only list field of "ListLike"; ditto "CollectionLike" --- MoreLinq/CollectionLike.cs | 10 +++++----- MoreLinq/ListLike.cs | 10 +++++----- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/MoreLinq/CollectionLike.cs b/MoreLinq/CollectionLike.cs index 16286cdb3..761cb401f 100644 --- a/MoreLinq/CollectionLike.cs +++ b/MoreLinq/CollectionLike.cs @@ -30,23 +30,23 @@ namespace MoreLinq readonly struct CollectionLike { readonly ICollection? _rw; - readonly IReadOnlyCollection? _rx; + readonly IReadOnlyCollection? _ro; public CollectionLike(ICollection collection) { _rw = collection ?? throw new ArgumentNullException(nameof(collection)); - _rx = null; + _ro = null; } public CollectionLike(IReadOnlyCollection collection) { _rw = null; - _rx = collection ?? throw new ArgumentNullException(nameof(collection)); + _ro = collection ?? throw new ArgumentNullException(nameof(collection)); } - public int Count => _rw?.Count ?? _rx?.Count ?? 0; + public int Count => _rw?.Count ?? _ro?.Count ?? 0; public IEnumerator GetEnumerator() => - _rw?.GetEnumerator() ?? _rx?.GetEnumerator() ?? Enumerable.Empty().GetEnumerator(); + _rw?.GetEnumerator() ?? _ro?.GetEnumerator() ?? Enumerable.Empty().GetEnumerator(); } } diff --git a/MoreLinq/ListLike.cs b/MoreLinq/ListLike.cs index 0773791b4..018dbb152 100644 --- a/MoreLinq/ListLike.cs +++ b/MoreLinq/ListLike.cs @@ -30,24 +30,24 @@ namespace MoreLinq readonly struct ListLike { readonly IList? _rw; - readonly IReadOnlyList? _rx; + readonly IReadOnlyList? _ro; public ListLike(IList list) { _rw = list ?? throw new ArgumentNullException(nameof(list)); - _rx = null; + _ro = null; } public ListLike(IReadOnlyList list) { _rw = null; - _rx = list ?? throw new ArgumentNullException(nameof(list)); + _ro = list ?? throw new ArgumentNullException(nameof(list)); } - public int Count => _rw?.Count ?? _rx?.Count ?? 0; + public int Count => _rw?.Count ?? _ro?.Count ?? 0; public T this[int index] => _rw is { } rw ? rw[index] - : _rx is { } rx ? rx[index] + : _ro is { } rx ? rx[index] : throw new ArgumentOutOfRangeException(nameof(index)); } From d6953fc3beb084b9275eac8eeeafdafbae38b119 Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Sat, 28 Jan 2023 05:49:49 -0600 Subject: [PATCH 051/157] Expand & test "TestingSequence" assertions --- MoreLinq.Test/MemoizeTest.cs | 4 +- MoreLinq.Test/TestingSequence.cs | 277 ++++++++++++++++++++++++--- MoreLinq.Test/WatchableEnumerator.cs | 14 +- 3 files changed, 260 insertions(+), 35 deletions(-) diff --git a/MoreLinq.Test/MemoizeTest.cs b/MoreLinq.Test/MemoizeTest.cs index f2bed5c5e..31ce2aeca 100644 --- a/MoreLinq.Test/MemoizeTest.cs +++ b/MoreLinq.Test/MemoizeTest.cs @@ -246,7 +246,7 @@ public void MemoizeRethrowsErrorDuringIterationToAllIteratorsUntilDisposed() var error = new TestException("This is a test exception."); using var xs = MoreEnumerable.From(() => 123, () => throw error) - .AsTestingSequence(TestingSequence.Options.AllowMultipleEnumerations); + .AsTestingSequence(maxEnumerations: 2); var memoized = xs.Memoize(); using ((IDisposable)memoized) using (var r1 = memoized.Read()) @@ -274,7 +274,7 @@ public void MemoizeRethrowsErrorDuringIterationStartToAllIteratorsUntilDisposed( using var xs = MoreEnumerable.From(() => 0 == i++ ? throw error // throw at start for first iteration only : 42) - .AsTestingSequence(TestingSequence.Options.AllowMultipleEnumerations); + .AsTestingSequence(maxEnumerations: 2); var memoized = xs.Memoize(); using ((IDisposable)memoized) using (var r1 = memoized.Read()) diff --git a/MoreLinq.Test/TestingSequence.cs b/MoreLinq.Test/TestingSequence.cs index 98572d7cc..479459a9b 100644 --- a/MoreLinq.Test/TestingSequence.cs +++ b/MoreLinq.Test/TestingSequence.cs @@ -20,27 +20,40 @@ namespace MoreLinq.Test using System; using System.Collections; using System.Collections.Generic; + using System.Text.RegularExpressions; using NUnit.Framework; + using static TestingSequence; static class TestingSequence { internal static TestingSequence Of(params T[] elements) => - Of(Options.None, elements); + new(elements, Options.None, maxEnumerations: 1); internal static TestingSequence Of(Options options, params T[] elements) => - elements.AsTestingSequence(options); + elements.AsTestingSequence(options, maxEnumerations: 1); internal static TestingSequence AsTestingSequence(this IEnumerable source, - Options options = Options.None) => + Options options = Options.None, + int maxEnumerations = 1) => source != null - ? new TestingSequence(source) { IsReiterationAllowed = options.HasFlag(Options.AllowMultipleEnumerations) } + ? new TestingSequence(source, options, maxEnumerations) : throw new ArgumentNullException(nameof(source)); + internal const string ExpectedDisposal = "Expected sequence to be disposed."; + internal const string TooManyEnumerations = "Sequence should not be enumerated more than expected."; + internal const string TooManyDisposals = "Sequence should not be disposed more than once per enumeration."; + internal const string SimultaneousEnumerations = "Sequence should not have simultaneous enumeration."; + internal const string MoveNextPostDisposal = "LINQ operators should not call MoveNext() on a disposed sequence."; + internal const string MoveNextPostEnumeration = "LINQ operators should not continue iterating a sequence that has terminated."; + internal const string CurrentPostDisposal = "LINQ operators should not attempt to get the Current value on a disposed sequence."; + internal const string CurrentPostEnumeration = "LINQ operators should not attempt to get the Current value on a completed sequence."; + [Flags] public enum Options { None, - AllowMultipleEnumerations + AllowRepeatedDisposals = 0x2, + AllowRepeatedMoveNexts = 0x4, } } @@ -51,59 +64,261 @@ public enum Options /// sealed class TestingSequence : IEnumerable, IDisposable { - bool? _disposed; - IEnumerable? _sequence; + readonly IEnumerable _sequence; + readonly Options _options; + readonly int _maxEnumerations; + + int _disposedCount; + int _enumerationCount; - internal TestingSequence(IEnumerable sequence) => + internal TestingSequence(IEnumerable sequence, Options options, int maxEnumerations) + { _sequence = sequence; + _maxEnumerations = maxEnumerations; + _options = options; + } - public bool IsDisposed => _disposed ?? false; - public bool IsReiterationAllowed { get; init; } public int MoveNextCallCount { get; private set; } + public bool IsDisposed => _enumerationCount > 0 && _disposedCount == _enumerationCount; - void IDisposable.Dispose() => - AssertDisposed(); - - /// - /// Checks that the iterator was disposed, and then resets. - /// - void AssertDisposed() + void IDisposable.Dispose() { - if (_disposed == null) - return; - Assert.That(_disposed, Is.True, "Expected sequence to be disposed."); - _disposed = null; + if (_enumerationCount > 0) + Assert.That(_disposedCount, Is.EqualTo(_enumerationCount), ExpectedDisposal); } public IEnumerator GetEnumerator() { - if (!IsReiterationAllowed) - Assert.That(_sequence, Is.Not.Null, "LINQ operators should not enumerate a sequence more than once."); - - Debug.Assert(_sequence is not null); + Assert.That(_enumerationCount, Is.LessThan(_maxEnumerations), TooManyEnumerations); + Assert.That(_enumerationCount, Is.EqualTo(_disposedCount), SimultaneousEnumerations); + _enumerationCount++; var enumerator = _sequence.GetEnumerator().AsWatchable(); - _disposed = false; + var disposed = false; enumerator.Disposed += delegate { - Assert.That(_disposed, Is.False, "LINQ operators should not dispose a sequence more than once."); - _disposed = true; + if (!disposed) + { + _disposedCount++; + disposed = true; + } + else if (!_options.HasFlag(Options.AllowRepeatedDisposals)) + { + Assert.Fail(TooManyDisposals); + } }; + var ended = false; enumerator.MoveNextCalled += (_, moved) => { - Assert.That(ended, Is.False, "LINQ operators should not continue iterating a sequence that has terminated."); + Assert.That(disposed, Is.False, MoveNextPostDisposal); + if (!_options.HasFlag(Options.AllowRepeatedMoveNexts)) + Assert.That(ended, Is.False, MoveNextPostEnumeration); + ended = !moved; MoveNextCallCount++; }; - if (!IsReiterationAllowed) - _sequence = null; + enumerator.GetCurrentCalled += delegate + { + Assert.That(disposed, Is.False, CurrentPostDisposal); + Assert.That(ended, Is.False, CurrentPostEnumeration); + }; return enumerator; } IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + } + + [TestFixture] + public class TestingSequenceTest + { + [Test] + public void TestingSequencePublicPropertiesTest() + { + using var sequence = Of(1, 2, 3, 4); + Assert.That(sequence.IsDisposed, Is.False); + Assert.That(sequence.MoveNextCallCount, Is.EqualTo(0)); + + var iter = sequence.GetEnumerator(); + Assert.That(sequence.IsDisposed, Is.False); + Assert.That(sequence.MoveNextCallCount, Is.EqualTo(0)); + + for (var i = 1; i <= 4; i++) + { + _ = iter.MoveNext(); + Assert.That(sequence.IsDisposed, Is.False); + Assert.That(sequence.MoveNextCallCount, Is.EqualTo(i)); + } + + iter.Dispose(); + Assert.That(sequence.IsDisposed, Is.True); + } + + [Test] + public void TestingSequenceShouldValidateDisposal() + { + static IEnumerable InvalidUsage(IEnumerable enumerable) + { + var _ = enumerable.GetEnumerator(); + + yield break; + } + + static void Act() + { + using var xs = Enumerable.Range(1, 10).AsTestingSequence(); + InvalidUsage(xs).Consume(); + } + + AssertTestingSequenceException(Act, ExpectedDisposal); + } + + [Test] + public void TestingSequenceShouldValidateNumberOfUsages() + { + static IEnumerable InvalidUsage(IEnumerable enumerable) + { + using (enumerable.GetEnumerator()) + yield return 1; + using (enumerable.GetEnumerator()) + yield return 2; + using (enumerable.GetEnumerator()) + yield return 3; + } + + static void Act() + { + using var xs = Enumerable.Range(1, 10).AsTestingSequence(maxEnumerations: 2); + InvalidUsage(xs).Consume(); + } + + AssertTestingSequenceException(Act, TooManyEnumerations); + } + + [Test] + public void TestingSequenceShouldValidateDisposeOnDisposedSequence() + { + static IEnumerable InvalidUsage(IEnumerable enumerable) + { + var enumerator = enumerable.GetEnumerator(); + enumerator.Dispose(); + enumerator.Dispose(); + + yield break; + } + + static void Act() + { + using var xs = Enumerable.Range(1, 10).AsTestingSequence(); + InvalidUsage(xs).Consume(); + } + + AssertTestingSequenceException(Act, TooManyDisposals); + } + + [Test] + public void TestingSequenceShouldValidateMoveNextOnDisposedSequence() + { + static IEnumerable InvalidUsage(IEnumerable enumerable) + { + var enumerator = enumerable.GetEnumerator(); + enumerator.Dispose(); + _ = enumerator.MoveNext(); + + yield break; + } + + static void Act() + { + using var xs = Enumerable.Range(1, 10).AsTestingSequence(); + InvalidUsage(xs).Consume(); + } + + AssertTestingSequenceException(Act, MoveNextPostDisposal); + } + + [Test] + public void TestingSequenceShouldValidateMoveNextOnCompletedSequence() + { + static IEnumerable InvalidUsage(IEnumerable enumerable) + { + using var enumerator = enumerable.GetEnumerator(); + while (enumerator.MoveNext()) + yield return enumerator.Current; + _ = enumerator.MoveNext(); + } + + static void Act() + { + using var xs = Enumerable.Range(1, 10).AsTestingSequence(); + InvalidUsage(xs).Consume(); + } + + AssertTestingSequenceException(Act, MoveNextPostEnumeration); + } + + [Test] + public void TestingSequenceShouldValidateCurrentOnDisposedSequence() + { + static IEnumerable InvalidUsage(IEnumerable enumerable) + { + var enumerator = enumerable.GetEnumerator(); + enumerator.Dispose(); + yield return enumerator.Current; + } + + static void Act() + { + using var xs = Enumerable.Range(1, 10).AsTestingSequence(); + InvalidUsage(xs).Consume(); + } + + AssertTestingSequenceException(Act, CurrentPostDisposal); + } + + [Test] + public void TestingSequenceShouldValidateCurrentOnEndedSequence() + { + static IEnumerable InvalidUsage(IEnumerable enumerable) + { + using var enumerator = enumerable.GetEnumerator(); + while (enumerator.MoveNext()) + yield return enumerator.Current; + yield return enumerator.Current; + } + + static void Act() + { + using var xs = Enumerable.Range(1, 10).AsTestingSequence(); + InvalidUsage(xs).Consume(); + } + + AssertTestingSequenceException(Act, CurrentPostEnumeration); + } + + [Test] + public void TestingSequenceShouldValidateSimultaneousEnumeration() + { + static IEnumerable InvalidUsage(IEnumerable enumerable) + { + using var enum1 = enumerable.GetEnumerator(); + using var enum2 = enumerable.GetEnumerator(); + + yield break; + } + + static void Act() + { + using var xs = Enumerable.Range(1, 10).AsTestingSequence(maxEnumerations: 2); + InvalidUsage(xs).Consume(); + } + + AssertTestingSequenceException(Act, SimultaneousEnumerations); + } + static void AssertTestingSequenceException(TestDelegate code, string message) => + Assert.That(code, Throws.InstanceOf().With.Message.Matches(@"^\s*" + Regex.Escape(message))); } } diff --git a/MoreLinq.Test/WatchableEnumerator.cs b/MoreLinq.Test/WatchableEnumerator.cs index cb6b14bef..4cb3d4221 100644 --- a/MoreLinq.Test/WatchableEnumerator.cs +++ b/MoreLinq.Test/WatchableEnumerator.cs @@ -31,13 +31,23 @@ sealed class WatchableEnumerator : IEnumerator readonly IEnumerator _source; public event EventHandler? Disposed; + public event EventHandler? GetCurrentCalled; public event EventHandler? MoveNextCalled; public WatchableEnumerator(IEnumerator source) => _source = source ?? throw new ArgumentNullException(nameof(source)); - public T Current => _source.Current; - object? IEnumerator.Current => Current; + public T Current + { + get + { + GetCurrentCalled?.Invoke(this, EventArgs.Empty); + return _source.Current; + } + } + + object? IEnumerator.Current => this.Current; + public void Reset() => _source.Reset(); public bool MoveNext() From a610d3a1c132bcfa403e8c989cfab4e5acc9a725 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 28 Jan 2023 12:51:15 +0100 Subject: [PATCH 052/157] Consolidate structural differences in "*Like" types --- MoreLinq/CollectionLike.cs | 12 ++++++++++++ MoreLinq/ListLike.cs | 6 ++---- MoreLinq/MoreEnumerable.cs | 9 --------- 3 files changed, 14 insertions(+), 13 deletions(-) diff --git a/MoreLinq/CollectionLike.cs b/MoreLinq/CollectionLike.cs index 761cb401f..42c642976 100644 --- a/MoreLinq/CollectionLike.cs +++ b/MoreLinq/CollectionLike.cs @@ -49,4 +49,16 @@ public CollectionLike(IReadOnlyCollection collection) public IEnumerator GetEnumerator() => _rw?.GetEnumerator() ?? _ro?.GetEnumerator() ?? Enumerable.Empty().GetEnumerator(); } + + static class CollectionLike + { + public static CollectionLike? TryAsCollectionLike(this IEnumerable source) => + source switch + { + null => throw new ArgumentNullException(nameof(source)), + ICollection collection => new(collection), + IReadOnlyCollection collection => new(collection), + _ => null + }; + } } diff --git a/MoreLinq/ListLike.cs b/MoreLinq/ListLike.cs index 018dbb152..7e774c47f 100644 --- a/MoreLinq/ListLike.cs +++ b/MoreLinq/ListLike.cs @@ -54,8 +54,6 @@ public ListLike(IReadOnlyList list) static class ListLike { public static ListLike AsListLike(this List list) => new((IList)list); - public static ListLike AsListLike(this IList list) => new(list); - public static ListLike AsListLike(this IReadOnlyList list) => new(list); public static ListLike ToListLike(this IEnumerable source) => source.TryAsListLike() ?? source.ToList().AsListLike(); @@ -64,8 +62,8 @@ public static ListLike ToListLike(this IEnumerable source) source switch { null => throw new ArgumentNullException(nameof(source)), - IList list => list.AsListLike(), - IReadOnlyList list => list.AsListLike(), + IList list => new(list), + IReadOnlyList list => new(list), _ => null }; } diff --git a/MoreLinq/MoreEnumerable.cs b/MoreLinq/MoreEnumerable.cs index 18aa05dd4..666158121 100644 --- a/MoreLinq/MoreEnumerable.cs +++ b/MoreLinq/MoreEnumerable.cs @@ -27,15 +27,6 @@ namespace MoreLinq public static partial class MoreEnumerable { - internal static CollectionLike? TryAsCollectionLike(this IEnumerable source) => - source switch - { - null => throw new ArgumentNullException(nameof(source)), - ICollection collection => new CollectionLike(collection), - IReadOnlyCollection collection => new CollectionLike(collection), - _ => null - }; - static int CountUpTo(this IEnumerable source, int max) { if (source == null) throw new ArgumentNullException(nameof(source)); From dec51ecc4676ee5a9e642ab7fda8bd70e78caa82 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 28 Jan 2023 19:55:58 +0100 Subject: [PATCH 053/157] Revert "Deploy package only on CI build of "deploy" branch" This reverts commit 321205a7b77c8d53385d37b6417970b9c20fc76e. Conflicts resolved: - .travis.yml - appveyor.yml --- appveyor.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/appveyor.yml b/appveyor.yml index 4d8cbda7a..74424cc37 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -20,7 +20,7 @@ for: secure: fhGwXyO35FSshRzs5GWmF1LJTrd1sIqmS/jNCSfO2LfOciuYAKiXuFMYZFGiTAl+ symbol_server: https://www.myget.org/F/morelinq/symbols/api/v2/package on: - branch: deploy + branch: master notifications: - provider: Email to: From 808874a11eb6f4f52ead62f62d10a9d1e263365f Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 29 Jan 2023 14:44:43 +0100 Subject: [PATCH 054/157] Revoke (obsolete) disabling of parallel builds This adds to commit "Revert "Integrate templated code generation into project file (#776)"" (0be76fdba6970dde3c62f50391491dca86f28e0d) that was merge of PR #940. --- MoreLinq/MoreLinq.csproj | 3 --- 1 file changed, 3 deletions(-) diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index b357ef6c4..392e66060 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -120,9 +120,6 @@ 3.3.2 MoreLINQ Developers. net462;netstandard1.0;netstandard2.0;netstandard2.1;net6.0 - - false portable true MoreLinq From 0f7f749a9f36bc899128885cf35fffcb26a67f20 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 29 Jan 2023 16:14:42 +0100 Subject: [PATCH 055/157] Run T4 templates if targets are out-of-date (#953) --- MoreLinq/MoreLinq.csproj | 28 ++++++++++++++++++++++++++++ MoreLinq/tt.cmd | 9 +-------- MoreLinq/tt.sh | 2 +- appveyor.yml | 2 ++ 4 files changed, 32 insertions(+), 9 deletions(-) diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 392e66060..50b11a3aa 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -154,6 +154,7 @@ + TextTemplatingFileGenerator Aggregate.g.cs @@ -244,4 +245,31 @@ + + + + %(None.LastGenOutput) + + + + + + + + + + + + + + + + + + + + diff --git a/MoreLinq/tt.cmd b/MoreLinq/tt.cmd index cbb7ac281..6ce54e7df 100644 --- a/MoreLinq/tt.cmd +++ b/MoreLinq/tt.cmd @@ -1,8 +1 @@ -@echo off -pushd "%~dp0" -for /f "tokens=*" %%f in ('dir /s /b *.tt') do ( - echo>&2 dotnet t4 "%%f" - dotnet t4 "%%f" || goto :end -) -:end -popd +@dotnet build "%~dp0MoreLinq.csproj" -t:TransformTextTemplates %* diff --git a/MoreLinq/tt.sh b/MoreLinq/tt.sh index 49be91c70..860ddfc35 100755 --- a/MoreLinq/tt.sh +++ b/MoreLinq/tt.sh @@ -1,4 +1,4 @@ #!/usr/bin/env bash set -e cd "$(dirname "$0")" -find . -name "*.tt" -print0 | xargs -0 -t -L 1 sh -c '(dotnet t4 "$0" || exit 255)' +dotnet build -t:TransformTextTemplates "$@" diff --git a/appveyor.yml b/appveyor.yml index 74424cc37..efb73541b 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -61,6 +61,8 @@ install: - sh: export PATH="$HOME/.dotnet:$PATH" before_build: - dotnet --info +# Touch T4 templates to force code generation & validation +- touch MoreLinq/*.g.tt build_script: - pwsh: | grep --extended-regexp '^[[:space:]]*using[[:space:]]+System\.Linq;' (dir -Recurse -File -Filter *Test.cs MoreLinq.Test) From 0a96b51bfec94bb53e408e691da8b18ca79dd551 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 29 Jan 2023 16:26:58 +0100 Subject: [PATCH 056/157] Discard unused expression value (IDE0058) (#954) --- MoreLinq.Test/NullArgumentTest.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/MoreLinq.Test/NullArgumentTest.cs b/MoreLinq.Test/NullArgumentTest.cs index a11d355ac..d17e2372a 100644 --- a/MoreLinq.Test/NullArgumentTest.cs +++ b/MoreLinq.Test/NullArgumentTest.cs @@ -45,7 +45,7 @@ static IEnumerable GetNotNullTestCases() => try { - method.Invoke(null, args); + _ = method.Invoke(null, args); } catch (TargetInvocationException tie) { From 3b5c013f023cfa3142e6e72d4a254afd5f6accc3 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 29 Jan 2023 17:25:50 +0100 Subject: [PATCH 057/157] Insert final newline in tools config file [ci skip] --- .config/dotnet-tools.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json index 1434359fd..6cf346f67 100644 --- a/.config/dotnet-tools.json +++ b/.config/dotnet-tools.json @@ -15,4 +15,4 @@ ] } } -} \ No newline at end of file +} From 53b12173b4089d845867d39f36b6a0c52fe45a0c Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 29 Jan 2023 17:58:12 +0100 Subject: [PATCH 058/157] Remove testing on .NET Core 3.1 that's no longer supported .NET Core 3.1 reached end-of-life on December 13, 2022: https://dotnet.microsoft.com/en-us/download/dotnet/3.1 --- MoreLinq.Test/MoreLinq.Test.csproj | 2 +- MoreLinq.Test/NullArgumentTest.cs | 6 ------ appveyor.yml | 2 -- test.cmd | 2 -- test.sh | 2 +- 5 files changed, 2 insertions(+), 12 deletions(-) diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index 198a6756e..32d7ac7b7 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -2,7 +2,7 @@ MoreLinq.Test - net7.0;net6.0;netcoreapp3.1;net462 + net7.0;net6.0;net462 portable MoreLinq.Test Exe diff --git a/MoreLinq.Test/NullArgumentTest.cs b/MoreLinq.Test/NullArgumentTest.cs index d17e2372a..9cd3ec8cd 100644 --- a/MoreLinq.Test/NullArgumentTest.cs +++ b/MoreLinq.Test/NullArgumentTest.cs @@ -57,12 +57,6 @@ static IEnumerable GetNotNullTestCases() => Debug.Assert(e is not null); var stackTrace = new StackTrace(e, false); var stackFrame = stackTrace.GetFrames().First(); -#if NETCOREAPP3_1 - // Under .NET Core 3.1, "StackTrace.GetFrames()" was defined to return an array - // of nullable frame elements. See: - // https://github.com/dotnet/corefx/blob/v3.1.32/src/Common/src/CoreLib/System/Diagnostics/StackTrace.cs#L162 - Debug.Assert(stackFrame is not null); -#endif var actualType = stackFrame.GetMethod()?.DeclaringType; Assert.That(actualType, Is.SameAs(typeof(MoreEnumerable))); }); diff --git a/appveyor.yml b/appveyor.yml index efb73541b..0ac9ab5a6 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -53,10 +53,8 @@ install: - eclint check -w "**/*.{cs,tt,cmd,sh,md,txt,yml,json,sln,csproj,shfbproj}" - git reset --hard - ps: if ($isWindows) { tools\dotnet-install.ps1 -JSonFile global.json } -- ps: if ($isWindows) { tools\dotnet-install.ps1 -Runtime dotnet -Version 3.1.10 -SkipNonVersionedFiles } - ps: if ($isWindows) { tools\dotnet-install.ps1 -Runtime dotnet -Version 6.0.11 -SkipNonVersionedFiles } - sh: ./tools/dotnet-install.sh --jsonfile global.json -- sh: ./tools/dotnet-install.sh --runtime dotnet --version 3.1.10 --skip-non-versioned-files - sh: ./tools/dotnet-install.sh --runtime dotnet --version 6.0.11 --skip-non-versioned-files - sh: export PATH="$HOME/.dotnet:$PATH" before_build: diff --git a/test.cmd b/test.cmd index 7f87f56c0..eec32dd03 100644 --- a/test.cmd +++ b/test.cmd @@ -12,8 +12,6 @@ call build ^ && call :test net7.0 Release ^ && call :test net6.0 Debug ^ && call :test net6.0 Release ^ - && call :test netcoreapp3.1 Debug ^ - && call :test netcoreapp3.1 Release ^ && call :test net462 Debug ^ && call :test net462 Release ^ && call :report-cover diff --git a/test.sh b/test.sh index c228eabe2..90d26eff9 100755 --- a/test.sh +++ b/test.sh @@ -10,7 +10,7 @@ if [[ -z "$1" ]]; then else configs="$1" fi -for f in netcoreapp3.1 net6.0 net7.0; do +for f in net6.0 net7.0; do for c in $configs; do dotnet test --no-build -c $c -f $f --settings MoreLinq.Test/coverlet.runsettings MoreLinq.Test TEST_RESULTS_DIR="$(ls -dc MoreLinq.Test/TestResults/* | head -1)" From 47747ef7b1c2ddeae47dcba9653bed4a1cfd2102 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 29 Jan 2023 21:37:46 +0100 Subject: [PATCH 059/157] Dynamically discover/build glob for ECLint (#957) --- appveyor.yml | 4 ++-- eclint.ps1 | 55 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+), 2 deletions(-) create mode 100644 eclint.ps1 diff --git a/appveyor.yml b/appveyor.yml index 0ac9ab5a6..8669892fe 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -49,8 +49,8 @@ skip_commits: install: - npm install -g eclint - git rm .editorconfig -- eclint check -n "**/*.{cs,tt,cmd,sh,md,txt,yml}" -- eclint check -w "**/*.{cs,tt,cmd,sh,md,txt,yml,json,sln,csproj,shfbproj}" +- pwsh: ./eclint.ps1 -InsertFinalNewline -Verbose +- pwsh: ./eclint.ps1 -TrimTrailingWhitespace -Verbose - git reset --hard - ps: if ($isWindows) { tools\dotnet-install.ps1 -JSonFile global.json } - ps: if ($isWindows) { tools\dotnet-install.ps1 -Runtime dotnet -Version 6.0.11 -SkipNonVersionedFiles } diff --git a/eclint.ps1 b/eclint.ps1 new file mode 100644 index 000000000..3bc6ece3c --- /dev/null +++ b/eclint.ps1 @@ -0,0 +1,55 @@ +[CmdletBinding(DefaultParameterSetName='Default')] +param ( + [Parameter(ParameterSetName='Default')] + [switch]$TrimTrailingWhitespace, + [Parameter(ParameterSetName='Default')] + [switch]$InsertFinalNewline, + + [Parameter(Mandatory=$true, ParameterSetName='ShowGlob')] + [switch]$ShowGlob +) + +$ErrorActionPreference = 'Stop' + +$exts = + git ls-files --eol | # get versioned file paths with line endings + ? { $_ -notmatch '/-text\b' } | # exclude binary files + % { ($_ -split '\t', 2)[1] } | # get file path + Split-Path -Extension | # get file extension + ? { $_.Length -gt 1 } | # exclude those without an extension + Sort-Object | # sort alphabetically + Select-Object -Unique | # remove duplicates + % { $_.Substring(1) } # remove leading dot + +$glob = "**/*.{$($exts -join ',')}" + +if ($PSCmdlet.ParameterSetName -eq 'ShowGlob') { + Write-Output $glob + return +} + +if (-not (Get-Command eclint -ErrorAction SilentlyContinue)) { + throw 'ECLint is not installed. To install, run: npm install -g eclint' +} + +$rules = @() + +if ($trimTrailingWhitespace) { + $rules += '--trim_trailing_whitespace' +} + +if ($insertFinalNewline) { + $rules += '--insert_final_newline' +} + +$rules | % { + + Write-Verbose "eclint check $rule $glob" + + # https://github.com/jednano/eclint + eclint check $_ $glob + + if ($LASTEXITCODE) { + throw "eclint terminated with a non-zero exit code ($LASTEXITCODE)." + } +} From f6bc02ae4aa600afc64ef97bd7476018d8d74e45 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 29 Jan 2023 23:08:50 +0100 Subject: [PATCH 060/157] Separate build pre-/post-validation into relevant CI sections --- appveyor.yml | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/appveyor.yml b/appveyor.yml index 8669892fe..a59f94da0 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -59,9 +59,6 @@ install: - sh: export PATH="$HOME/.dotnet:$PATH" before_build: - dotnet --info -# Touch T4 templates to force code generation & validation -- touch MoreLinq/*.g.tt -build_script: - pwsh: | grep --extended-regexp '^[[:space:]]*using[[:space:]]+System\.Linq;' (dir -Recurse -File -Filter *Test.cs MoreLinq.Test) if ($LASTEXITCODE -eq 0) { @@ -69,6 +66,9 @@ build_script: } else { $LASTEXITCODE = 0 } +# Touch T4 templates to force code generation & validation +- touch MoreLinq/*.g.tt +build_script: - ps: | $id = $env:APPVEYOR_REPO_COMMIT_TIMESTAMP -replace '([-:]|\.0+Z)', '' $id = $id.Substring(0, 13) @@ -76,6 +76,8 @@ build_script: if ($LASTEXITCODE -ne 0) { throw "Building/Packing failed with an exit code of $LASTEXITCODE." } +after_build: +- ps: | $diff = git diff --ignore-all-space --exit-code 2>&1 $diff | % { if ($_ -is [string]) { $_ } else { [string]$_ } } | echo if ($LASTEXITCODE -ne 0) { From 283c44c046b45af688262fe37a3076da28060937 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 28 Jan 2023 19:43:10 +0100 Subject: [PATCH 061/157] Fix some doc comments Fixes: - formatting - inconsistencies - grammar - wrapping - code examples for following operators: - Interleave - Lag - Lead - Permutations - Slice - SortedMerge - Subsets - Window --- MoreLinq/Extensions.g.cs | 315 ++++++++++++++++++++++++--------------- MoreLinq/Interleave.cs | 33 ++-- MoreLinq/Lag.cs | 50 ++++--- MoreLinq/Lead.cs | 51 ++++--- MoreLinq/Permutations.cs | 16 +- MoreLinq/Slice.cs | 30 ++-- MoreLinq/SortedMerge.cs | 67 +++++---- MoreLinq/Subsets.cs | 49 +++--- MoreLinq/Window.cs | 37 +++-- 9 files changed, 397 insertions(+), 251 deletions(-) diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index 964d46902..a5ca2ac81 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -3021,24 +3021,31 @@ public static IEnumerable Insert(this IEnumerable first, IEnumerable public static partial class InterleaveExtension { /// - /// Interleaves the elements of two or more sequences into a single sequence, skipping sequences as they are consumed + /// Interleaves the elements of two or more sequences into a single sequence, skipping + /// sequences as they are consumed. /// + /// The type of the elements of the source sequences. + /// The first sequence in the interleave group. + /// The other sequences in the interleave group. + /// A sequence of interleaved elements from all of the source sequences. /// - /// Interleave combines sequences by visiting each in turn, and returning the first element of each, followed - /// by the second, then the third, and so on. So, for example:
+ /// + /// Interleave combines sequences by visiting each in turn, and returning the first element + /// of each, followed by the second, then the third, and so on. So, for example: /// { 1,2,3,1,2,3,1,2,3 } + /// var xs = new[] { 1, 1, 1 }.Interleave(new[] { 2, 2, 2 }, new[] { 3, 3, 3 }); + /// // xs = { 1, 2, 3, 1, 2, 3, 1, 2, 3 } /// ]]> - /// This operator behaves in a deferred and streaming manner.
- /// When sequences are of unequal length, this method will skip those sequences that have been fully consumed - /// and continue interleaving the remaining sequences.
- /// The sequences are interleaved in the order that they appear in the - /// collection, with as the first sequence. + /// + /// This operator behaves in a deferred and streaming manner. + /// + /// When sequences are of unequal length, this method will skip those sequences that have + /// been fully consumed and continue interleaving the remaining sequences. + /// + /// The sequences are interleaved in the order that they appear in the collection, with as the first + /// sequence. /// - /// The type of the elements of the source sequences - /// The first sequence in the interleave group - /// The other sequences in the interleave group - /// A sequence of interleaved elements from all of the source sequences public static IEnumerable Interleave(this IEnumerable sequence, params IEnumerable[] otherSequences) => MoreEnumerable.Interleave(sequence, otherSequences); @@ -3051,35 +3058,49 @@ public static IEnumerable Interleave(this IEnumerable sequence, params public static partial class LagExtension { /// - /// Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset. + /// Produces a projection of a sequence by evaluating pairs of elements separated by a + /// negative offset. /// + /// The type of the elements of the source sequence. + /// The type of the elements of the result sequence. + /// The sequence over which to evaluate lag. + /// The offset (expressed as a positive number) by which to lag each + /// value of the sequence. + /// A projection function which accepts the current and lagged + /// items (in that order) and returns a result. + /// + /// A sequence produced by projecting each element of the sequence with its lagged + /// pairing. /// - /// This operator evaluates in a deferred and streaming manner.
- /// For elements prior to the lag offset, default(T) is used as the lagged value.
+ /// + /// This operator evaluates in a deferred and streaming manner. + /// + /// For elements prior to the lag offset, default(T) is used as the lagged + /// value. /// - /// The type of the elements of the source sequence - /// The type of the elements of the result sequence - /// The sequence over which to evaluate lag - /// The offset (expressed as a positive number) by which to lag each value of the sequence - /// A projection function which accepts the current and lagged items (in that order) and returns a result - /// A sequence produced by projecting each element of the sequence with its lagged pairing public static IEnumerable Lag(this IEnumerable source, int offset, Func resultSelector) => MoreEnumerable.Lag(source, offset, resultSelector); /// - /// Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset. + /// Produces a projection of a sequence by evaluating pairs of elements separated by a + /// negative offset. /// + /// The type of the elements of the source sequence. + /// The type of the elements of the result sequence. + /// The sequence over which to evaluate lag. + /// The offset (expressed as a positive number) by which to lag each + /// value of the sequence. + /// A default value supplied for the lagged value prior to the + /// lag offset. + /// A projection function which accepts the current and lagged + /// items (in that order) and returns a result. + /// + /// A sequence produced by projecting each element of the sequence with its lagged + /// pairing. /// - /// This operator evaluates in a deferred and streaming manner.
+ /// This operator evaluates in a deferred and streaming manner. /// - /// The type of the elements of the source sequence - /// The type of the elements of the result sequence - /// The sequence over which to evaluate lag - /// The offset (expressed as a positive number) by which to lag each value of the sequence - /// A default value supplied for the lagged value prior to the lag offset - /// A projection function which accepts the current and lagged items (in that order) and returns a result - /// A sequence produced by projecting each element of the sequence with its lagged pairing public static IEnumerable Lag(this IEnumerable source, int offset, TSource defaultLagValue, Func resultSelector) => MoreEnumerable.Lag(source, offset, defaultLagValue, resultSelector); @@ -3138,36 +3159,49 @@ public static partial class LastOrDefaultExtension public static partial class LeadExtension { /// - /// Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset. + /// Produces a projection of a sequence by evaluating pairs of elements separated by a + /// positive offset. /// + /// The type of the elements in the source sequence. + /// The type of the elements in the result sequence. + /// The sequence over which to evaluate lead. + /// The offset (expressed as a positive number) by which to lead each + /// element of the sequence. + /// A projection function which accepts the current and + /// subsequent (lead) element (in that order) and produces a result. + /// + /// A sequence produced by projecting each element of the sequence with its lead + /// pairing. /// - /// This operator evaluates in a deferred and streaming manner.
- /// For elements of the sequence that are less than items from the end, - /// default(T) is used as the lead value.
+ /// + /// This operator evaluates in a deferred and streaming manner. + /// + /// For elements of the sequence that are less than items from the + /// end, default(T) is used as the lead value. /// - /// The type of the elements in the source sequence - /// The type of the elements in the result sequence - /// The sequence over which to evaluate Lead - /// The offset (expressed as a positive number) by which to lead each element of the sequence - /// A projection function which accepts the current and subsequent (lead) element (in that order) and produces a result - /// A sequence produced by projecting each element of the sequence with its lead pairing public static IEnumerable Lead(this IEnumerable source, int offset, Func resultSelector) => MoreEnumerable.Lead(source, offset, resultSelector); /// - /// Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset. + /// Produces a projection of a sequence by evaluating pairs of elements separated by a + /// positive offset. /// + /// The type of the elements in the source sequence. + /// The type of the elements in the result sequence. + /// The sequence over which to evaluate Lead. + /// The offset (expressed as a positive number) by which to lead each + /// element of the sequence. + /// A default value supplied for the leading element when + /// none is available. + /// A projection function which accepts the current and + /// subsequent (lead) element (in that order) and produces a result. + /// + /// A sequence produced by projecting each element of the sequence with its lead + /// pairing. /// - /// This operator evaluates in a deferred and streaming manner.
+ /// This operator evaluates in a deferred and streaming manner. /// - /// The type of the elements in the source sequence - /// The type of the elements in the result sequence - /// The sequence over which to evaluate Lead - /// The offset (expressed as a positive number) by which to lead each element of the sequence - /// A default value supplied for the leading element when none is available - /// A projection function which accepts the current and subsequent (lead) element (in that order) and produces a result - /// A sequence produced by projecting each element of the sequence with its lead pairing public static IEnumerable Lead(this IEnumerable source, int offset, TSource defaultLeadValue, Func resultSelector) => MoreEnumerable.Lead(source, offset, defaultLeadValue, resultSelector); @@ -4457,17 +4491,21 @@ public static partial class PermutationsExtension /// /// Generates a sequence of lists that represent the permutations of the original sequence. /// + /// The type of the elements in the sequence. + /// The original sequence to permute. + /// + /// A sequence of lists representing permutations of the original sequence. /// - /// A permutation is a unique re-ordering of the elements of the sequence.
+ /// + /// A permutation is a unique re-ordering of the elements of the sequence. + /// /// This operator returns permutations in a deferred, streaming fashion; however, each /// permutation is materialized into a new list. There are N! permutations of a sequence, - /// where N => sequence.Count().
+ /// where N ⇒ sequence.Count(). + /// /// Be aware that the original sequence is considered one of the permutations and will be - /// returned as one of the results. + /// returned as one of the results. /// - /// The type of the elements in the sequence - /// The original sequence to permute - /// A sequence of lists representing permutations of the original sequence public static IEnumerable> Permutations(this IEnumerable sequence) => MoreEnumerable.Permutations(sequence); @@ -5301,20 +5339,28 @@ public static IEnumerable SkipUntil(this IEnumerable public static partial class SliceExtension { /// - /// Extracts a contiguous count of elements from a sequence at a particular zero-based starting index + /// Extracts a contiguous count of elements from a sequence at a particular zero-based + /// starting index. /// + /// The type of the elements in the source sequence. + /// The sequence from which to extract elements. + /// The zero-based index at which to begin slicing. + /// The number of items to slice out of the index. + /// + /// A new sequence containing any elements sliced out from the source sequence. /// - /// If the starting position or count specified result in slice extending past the end of the sequence, - /// it will return all elements up to that point. There is no guarantee that the resulting sequence will - /// contain the number of elements requested - it may have anywhere from 0 to .
- /// This method is implemented in an optimized manner for any sequence implementing IList{T}.
- /// The result of Slice() is identical to: sequence.Skip(startIndex).Take(count) + /// + /// If the starting position or count specified result in slice extending past the end of + /// the sequence, it will return all elements up to that point. There is no guarantee that + /// the resulting sequence will contain the number of elements requested - it may have + /// anywhere from 0 to . + /// + /// This method is implemented in an optimized manner for any sequence implementing . + /// + /// The result of is identical to: + /// sequence.Skip(startIndex).Take(count) /// - /// The type of the elements in the source sequence - /// The sequence from which to extract elements - /// The zero-based index at which to begin slicing - /// The number of items to slice out of the index - /// A new sequence containing any elements sliced out from the source sequence public static IEnumerable Slice(this IEnumerable sequence, int startIndex, int count) => MoreEnumerable.Slice(sequence, startIndex, count); @@ -5327,44 +5373,57 @@ public static IEnumerable Slice(this IEnumerable sequence, int startInd public static partial class SortedMergeExtension { /// - /// Merges two or more sequences that are in a common order (either ascending or descending) into - /// a single sequence that preserves that order. + /// Merges two or more sequences that are in a common order (either ascending or descending) + /// into a single sequence that preserves that order. /// + /// The type of the elements of the sequence. + /// The primary sequence with which to merge. + /// The ordering that all sequences must already exhibit. + /// A variable argument array of zero or more other sequences + /// to merge with. + /// + /// A merged, order-preserving sequence containing all of the elements of the original + /// sequences. /// - /// Using SortedMerge on sequences that are not ordered or are not in the same order produces - /// undefined results.
- /// SortedMerge uses performs the merge in a deferred, streaming manner.
- /// - /// Here is an example of a merge, as well as the produced result: + /// + /// Using + /// on sequences that are not ordered or are not in the same order produces undefined + /// results. + /// + /// + /// uses performs the merge in a deferred, streaming manner. + /// + /// Here is an example of a merge, as well as the produced result: /// /// - /// The type of the elements of the sequence - /// The primary sequence with which to merge - /// The ordering that all sequences must already exhibit - /// A variable argument array of zero or more other sequences to merge with - /// A merged, order-preserving sequence containing all of the elements of the original sequences public static IEnumerable SortedMerge(this IEnumerable source, OrderByDirection direction, params IEnumerable[] otherSequences) => MoreEnumerable.SortedMerge(source, direction, otherSequences); /// - /// Merges two or more sequences that are in a common order (either ascending or descending) into - /// a single sequence that preserves that order. + /// Merges two or more sequences that are in a common order (either ascending or descending) + /// into a single sequence that preserves that order. /// - /// The type of the elements in the sequence - /// The primary sequence with which to merge - /// The ordering that all sequences must already exhibit - /// The comparer used to evaluate the relative order between elements - /// A variable argument array of zero or more other sequences to merge with - /// A merged, order-preserving sequence containing al of the elements of the original sequences + /// The type of the elements in the sequence. + /// The primary sequence with which to merge. + /// The ordering that all sequences must already exhibit. + /// The comparer used to evaluate the relative order between + /// elements. + /// A variable argument array of zero or more other sequences + /// to merge with. + /// + /// A merged, order-preserving sequence containing al of the elements of the original + /// sequences. public static IEnumerable SortedMerge(this IEnumerable source, OrderByDirection direction, IComparer? comparer, params IEnumerable[] otherSequences) => MoreEnumerable.SortedMerge(source, direction, comparer, otherSequences); @@ -5650,38 +5709,45 @@ public static bool StartsWith(this IEnumerable first, IEnumerable secon public static partial class SubsetsExtension { /// - /// Returns a sequence of representing all of - /// the subsets of any size that are part of the original sequence. In - /// mathematics, it is equivalent to the power set of a set. + /// Returns a sequence of representing all of the subsets of any size + /// that are part of the original sequence. In mathematics, it is equivalent to the + /// power set of a set. /// + /// Sequence for which to produce subsets. + /// The type of the elements in the sequence. + /// + /// A sequence of lists that represent the all subsets of the original sequence. + /// Thrown if is . /// - /// This operator produces all of the subsets of a given sequence. Subsets are returned - /// in increasing cardinality, starting with the empty set and terminating with the - /// entire original sequence.
+ /// + /// This operator produces all of the subsets of a given sequence. Subsets are returned in + /// increasing cardinality, starting with the empty set and terminating with the entire + /// original sequence. + /// /// Subsets are produced in a deferred, streaming manner; however, each subset is returned - /// as a materialized list.
- /// There are 2^N subsets of a given sequence, where N => sequence.Count(). + /// as a materialized list. + /// + /// There are 2N subsets of a given sequence, where N ⇒ + /// sequence.Count(). /// - /// Sequence for which to produce subsets - /// The type of the elements in the sequence - /// A sequence of lists that represent the all subsets of the original sequence - /// Thrown if is public static IEnumerable> Subsets(this IEnumerable sequence) => MoreEnumerable.Subsets(sequence); /// - /// Returns a sequence of representing all - /// subsets of a given size that are part of the original sequence. In - /// mathematics, it is equivalent to the combinations or - /// k-subsets of a set. + /// Returns a sequence of representing all subsets of a given size + /// that are part of the original sequence. In mathematics, it is equivalent to the + /// combinations or k-subsets of a set. /// - /// Sequence for which to produce subsets - /// The size of the subsets to produce - /// The type of the elements in the sequence - /// A sequence of lists that represents of K-sized subsets of the original sequence + /// Sequence for which to produce subsets. + /// The size of the subsets to produce. + /// The type of the elements in the sequence. + /// + /// A sequence of lists that represents of K-sized subsets of the original + /// sequence. /// - /// Thrown if is + /// Thrown if is . /// /// /// Thrown if is less than zero. @@ -6689,16 +6755,21 @@ public static IEnumerable> Transpose(this IEnumerable - /// Processes a sequence into a series of sub-sequences representing a windowed subset of the original + /// Processes a sequence into a series of sub-sequences representing a windowed subset of + /// the original. /// + /// The type of the elements of the source sequence. + /// The sequence to evaluate a sliding window over. + /// The size (number of elements) in each window. + /// + /// A series of sequences representing each sliding window subsequence. /// - /// The number of sequences returned is: Max(0, sequence.Count() - windowSize) + 1
- /// Returned sub-sequences are buffered, but the overall operation is streamed.
+ /// + /// The number of sequences returned is: Max(0, sequence.Count() - windowSize) + + /// 1 + /// + /// Returned sub-sequences are buffered, but the overall operation is streamed. /// - /// The type of the elements of the source sequence - /// The sequence to evaluate a sliding window over - /// The size (number of elements) in each window - /// A series of sequences representing each sliding window subsequence public static IEnumerable> Window(this IEnumerable source, int size) => MoreEnumerable.Window(source, size); diff --git a/MoreLinq/Interleave.cs b/MoreLinq/Interleave.cs index 9912eef20..c053341d5 100644 --- a/MoreLinq/Interleave.cs +++ b/MoreLinq/Interleave.cs @@ -24,24 +24,31 @@ namespace MoreLinq public static partial class MoreEnumerable { /// - /// Interleaves the elements of two or more sequences into a single sequence, skipping sequences as they are consumed + /// Interleaves the elements of two or more sequences into a single sequence, skipping + /// sequences as they are consumed. /// + /// The type of the elements of the source sequences. + /// The first sequence in the interleave group. + /// The other sequences in the interleave group. + /// A sequence of interleaved elements from all of the source sequences. /// - /// Interleave combines sequences by visiting each in turn, and returning the first element of each, followed - /// by the second, then the third, and so on. So, for example:
+ /// + /// Interleave combines sequences by visiting each in turn, and returning the first element + /// of each, followed by the second, then the third, and so on. So, for example: /// { 1,2,3,1,2,3,1,2,3 } + /// var xs = new[] { 1, 1, 1 }.Interleave(new[] { 2, 2, 2 }, new[] { 3, 3, 3 }); + /// // xs = { 1, 2, 3, 1, 2, 3, 1, 2, 3 } /// ]]> - /// This operator behaves in a deferred and streaming manner.
- /// When sequences are of unequal length, this method will skip those sequences that have been fully consumed - /// and continue interleaving the remaining sequences.
- /// The sequences are interleaved in the order that they appear in the - /// collection, with as the first sequence. + /// + /// This operator behaves in a deferred and streaming manner. + /// + /// When sequences are of unequal length, this method will skip those sequences that have + /// been fully consumed and continue interleaving the remaining sequences. + /// + /// The sequences are interleaved in the order that they appear in the collection, with as the first + /// sequence. /// - /// The type of the elements of the source sequences - /// The first sequence in the interleave group - /// The other sequences in the interleave group - /// A sequence of interleaved elements from all of the source sequences public static IEnumerable Interleave(this IEnumerable sequence, params IEnumerable[] otherSequences) { diff --git a/MoreLinq/Lag.cs b/MoreLinq/Lag.cs index 66bd4a1e7..4b532a649 100644 --- a/MoreLinq/Lag.cs +++ b/MoreLinq/Lag.cs @@ -24,18 +24,26 @@ namespace MoreLinq public static partial class MoreEnumerable { /// - /// Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset. + /// Produces a projection of a sequence by evaluating pairs of elements separated by a + /// negative offset. /// + /// The type of the elements of the source sequence. + /// The type of the elements of the result sequence. + /// The sequence over which to evaluate lag. + /// The offset (expressed as a positive number) by which to lag each + /// value of the sequence. + /// A projection function which accepts the current and lagged + /// items (in that order) and returns a result. + /// + /// A sequence produced by projecting each element of the sequence with its lagged + /// pairing. /// - /// This operator evaluates in a deferred and streaming manner.
- /// For elements prior to the lag offset, default(T) is used as the lagged value.
+ /// + /// This operator evaluates in a deferred and streaming manner. + /// + /// For elements prior to the lag offset, default(T) is used as the lagged + /// value. /// - /// The type of the elements of the source sequence - /// The type of the elements of the result sequence - /// The sequence over which to evaluate lag - /// The offset (expressed as a positive number) by which to lag each value of the sequence - /// A projection function which accepts the current and lagged items (in that order) and returns a result - /// A sequence produced by projecting each element of the sequence with its lagged pairing public static IEnumerable Lag(this IEnumerable source, int offset, Func resultSelector) { @@ -47,18 +55,24 @@ public static IEnumerable Lag(this IEnumerable - /// Produces a projection of a sequence by evaluating pairs of elements separated by a negative offset. + /// Produces a projection of a sequence by evaluating pairs of elements separated by a + /// negative offset. /// + /// The type of the elements of the source sequence. + /// The type of the elements of the result sequence. + /// The sequence over which to evaluate lag. + /// The offset (expressed as a positive number) by which to lag each + /// value of the sequence. + /// A default value supplied for the lagged value prior to the + /// lag offset. + /// A projection function which accepts the current and lagged + /// items (in that order) and returns a result. + /// + /// A sequence produced by projecting each element of the sequence with its lagged + /// pairing. /// - /// This operator evaluates in a deferred and streaming manner.
+ /// This operator evaluates in a deferred and streaming manner. /// - /// The type of the elements of the source sequence - /// The type of the elements of the result sequence - /// The sequence over which to evaluate lag - /// The offset (expressed as a positive number) by which to lag each value of the sequence - /// A default value supplied for the lagged value prior to the lag offset - /// A projection function which accepts the current and lagged items (in that order) and returns a result - /// A sequence produced by projecting each element of the sequence with its lagged pairing public static IEnumerable Lag(this IEnumerable source, int offset, TSource defaultLagValue, Func resultSelector) { diff --git a/MoreLinq/Lead.cs b/MoreLinq/Lead.cs index 25c7637c7..2a0b7cbb3 100644 --- a/MoreLinq/Lead.cs +++ b/MoreLinq/Lead.cs @@ -24,19 +24,26 @@ namespace MoreLinq public static partial class MoreEnumerable { /// - /// Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset. + /// Produces a projection of a sequence by evaluating pairs of elements separated by a + /// positive offset. /// + /// The type of the elements in the source sequence. + /// The type of the elements in the result sequence. + /// The sequence over which to evaluate lead. + /// The offset (expressed as a positive number) by which to lead each + /// element of the sequence. + /// A projection function which accepts the current and + /// subsequent (lead) element (in that order) and produces a result. + /// + /// A sequence produced by projecting each element of the sequence with its lead + /// pairing. /// - /// This operator evaluates in a deferred and streaming manner.
- /// For elements of the sequence that are less than items from the end, - /// default(T) is used as the lead value.
+ /// + /// This operator evaluates in a deferred and streaming manner. + /// + /// For elements of the sequence that are less than items from the + /// end, default(T) is used as the lead value. /// - /// The type of the elements in the source sequence - /// The type of the elements in the result sequence - /// The sequence over which to evaluate Lead - /// The offset (expressed as a positive number) by which to lead each element of the sequence - /// A projection function which accepts the current and subsequent (lead) element (in that order) and produces a result - /// A sequence produced by projecting each element of the sequence with its lead pairing public static IEnumerable Lead(this IEnumerable source, int offset, Func resultSelector) { @@ -48,18 +55,24 @@ public static IEnumerable Lead(this IEnumerable - /// Produces a projection of a sequence by evaluating pairs of elements separated by a positive offset. + /// Produces a projection of a sequence by evaluating pairs of elements separated by a + /// positive offset. /// + /// The type of the elements in the source sequence. + /// The type of the elements in the result sequence. + /// The sequence over which to evaluate Lead. + /// The offset (expressed as a positive number) by which to lead each + /// element of the sequence. + /// A default value supplied for the leading element when + /// none is available. + /// A projection function which accepts the current and + /// subsequent (lead) element (in that order) and produces a result. + /// + /// A sequence produced by projecting each element of the sequence with its lead + /// pairing. /// - /// This operator evaluates in a deferred and streaming manner.
+ /// This operator evaluates in a deferred and streaming manner. /// - /// The type of the elements in the source sequence - /// The type of the elements in the result sequence - /// The sequence over which to evaluate Lead - /// The offset (expressed as a positive number) by which to lead each element of the sequence - /// A default value supplied for the leading element when none is available - /// A projection function which accepts the current and subsequent (lead) element (in that order) and produces a result - /// A sequence produced by projecting each element of the sequence with its lead pairing public static IEnumerable Lead(this IEnumerable source, int offset, TSource defaultLeadValue, Func resultSelector) { diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs index d603f58f7..76204ec26 100644 --- a/MoreLinq/Permutations.cs +++ b/MoreLinq/Permutations.cs @@ -180,17 +180,21 @@ IList PermuteValueSet() /// /// Generates a sequence of lists that represent the permutations of the original sequence. /// + /// The type of the elements in the sequence. + /// The original sequence to permute. + /// + /// A sequence of lists representing permutations of the original sequence. /// - /// A permutation is a unique re-ordering of the elements of the sequence.
+ /// + /// A permutation is a unique re-ordering of the elements of the sequence. + /// /// This operator returns permutations in a deferred, streaming fashion; however, each /// permutation is materialized into a new list. There are N! permutations of a sequence, - /// where N => sequence.Count().
+ /// where N ⇒ sequence.Count(). + /// /// Be aware that the original sequence is considered one of the permutations and will be - /// returned as one of the results. + /// returned as one of the results. /// - /// The type of the elements in the sequence - /// The original sequence to permute - /// A sequence of lists representing permutations of the original sequence public static IEnumerable> Permutations(this IEnumerable sequence) { diff --git a/MoreLinq/Slice.cs b/MoreLinq/Slice.cs index 356ac356d..86f8306fa 100644 --- a/MoreLinq/Slice.cs +++ b/MoreLinq/Slice.cs @@ -24,20 +24,28 @@ namespace MoreLinq public static partial class MoreEnumerable { /// - /// Extracts a contiguous count of elements from a sequence at a particular zero-based starting index + /// Extracts a contiguous count of elements from a sequence at a particular zero-based + /// starting index. /// + /// The type of the elements in the source sequence. + /// The sequence from which to extract elements. + /// The zero-based index at which to begin slicing. + /// The number of items to slice out of the index. + /// + /// A new sequence containing any elements sliced out from the source sequence. /// - /// If the starting position or count specified result in slice extending past the end of the sequence, - /// it will return all elements up to that point. There is no guarantee that the resulting sequence will - /// contain the number of elements requested - it may have anywhere from 0 to .
- /// This method is implemented in an optimized manner for any sequence implementing IList{T}.
- /// The result of Slice() is identical to: sequence.Skip(startIndex).Take(count) + /// + /// If the starting position or count specified result in slice extending past the end of + /// the sequence, it will return all elements up to that point. There is no guarantee that + /// the resulting sequence will contain the number of elements requested - it may have + /// anywhere from 0 to . + /// + /// This method is implemented in an optimized manner for any sequence implementing . + /// + /// The result of is identical to: + /// sequence.Skip(startIndex).Take(count) /// - /// The type of the elements in the source sequence - /// The sequence from which to extract elements - /// The zero-based index at which to begin slicing - /// The number of items to slice out of the index - /// A new sequence containing any elements sliced out from the source sequence public static IEnumerable Slice(this IEnumerable sequence, int startIndex, int count) { diff --git a/MoreLinq/SortedMerge.cs b/MoreLinq/SortedMerge.cs index b19273c15..9f6aff425 100644 --- a/MoreLinq/SortedMerge.cs +++ b/MoreLinq/SortedMerge.cs @@ -24,30 +24,39 @@ namespace MoreLinq public static partial class MoreEnumerable { /// - /// Merges two or more sequences that are in a common order (either ascending or descending) into - /// a single sequence that preserves that order. + /// Merges two or more sequences that are in a common order (either ascending or descending) + /// into a single sequence that preserves that order. /// + /// The type of the elements of the sequence. + /// The primary sequence with which to merge. + /// The ordering that all sequences must already exhibit. + /// A variable argument array of zero or more other sequences + /// to merge with. + /// + /// A merged, order-preserving sequence containing all of the elements of the original + /// sequences. /// - /// Using SortedMerge on sequences that are not ordered or are not in the same order produces - /// undefined results.
- /// SortedMerge uses performs the merge in a deferred, streaming manner.
- /// - /// Here is an example of a merge, as well as the produced result: + /// + /// Using + /// on sequences that are not ordered or are not in the same order produces undefined + /// results. + /// + /// + /// uses performs the merge in a deferred, streaming manner. + /// + /// Here is an example of a merge, as well as the produced result: /// /// - /// The type of the elements of the sequence - /// The primary sequence with which to merge - /// The ordering that all sequences must already exhibit - /// A variable argument array of zero or more other sequences to merge with - /// A merged, order-preserving sequence containing all of the elements of the original sequences public static IEnumerable SortedMerge(this IEnumerable source, OrderByDirection direction, params IEnumerable[] otherSequences) { @@ -55,15 +64,19 @@ public static IEnumerable SortedMerge(this IEnumerable - /// Merges two or more sequences that are in a common order (either ascending or descending) into - /// a single sequence that preserves that order. + /// Merges two or more sequences that are in a common order (either ascending or descending) + /// into a single sequence that preserves that order. /// - /// The type of the elements in the sequence - /// The primary sequence with which to merge - /// The ordering that all sequences must already exhibit - /// The comparer used to evaluate the relative order between elements - /// A variable argument array of zero or more other sequences to merge with - /// A merged, order-preserving sequence containing al of the elements of the original sequences + /// The type of the elements in the sequence. + /// The primary sequence with which to merge. + /// The ordering that all sequences must already exhibit. + /// The comparer used to evaluate the relative order between + /// elements. + /// A variable argument array of zero or more other sequences + /// to merge with. + /// + /// A merged, order-preserving sequence containing al of the elements of the original + /// sequences. public static IEnumerable SortedMerge(this IEnumerable source, OrderByDirection direction, IComparer? comparer, params IEnumerable[] otherSequences) { diff --git a/MoreLinq/Subsets.cs b/MoreLinq/Subsets.cs index 65054f529..bb5752723 100644 --- a/MoreLinq/Subsets.cs +++ b/MoreLinq/Subsets.cs @@ -25,22 +25,28 @@ namespace MoreLinq public static partial class MoreEnumerable { /// - /// Returns a sequence of representing all of - /// the subsets of any size that are part of the original sequence. In - /// mathematics, it is equivalent to the power set of a set. + /// Returns a sequence of representing all of the subsets of any size + /// that are part of the original sequence. In mathematics, it is equivalent to the + /// power set of a set. /// + /// Sequence for which to produce subsets. + /// The type of the elements in the sequence. + /// + /// A sequence of lists that represent the all subsets of the original sequence. + /// Thrown if is . /// - /// This operator produces all of the subsets of a given sequence. Subsets are returned - /// in increasing cardinality, starting with the empty set and terminating with the - /// entire original sequence.
+ /// + /// This operator produces all of the subsets of a given sequence. Subsets are returned in + /// increasing cardinality, starting with the empty set and terminating with the entire + /// original sequence. + /// /// Subsets are produced in a deferred, streaming manner; however, each subset is returned - /// as a materialized list.
- /// There are 2^N subsets of a given sequence, where N => sequence.Count(). + /// as a materialized list. + /// + /// There are 2N subsets of a given sequence, where N ⇒ + /// sequence.Count(). /// - /// Sequence for which to produce subsets - /// The type of the elements in the sequence - /// A sequence of lists that represent the all subsets of the original sequence - /// Thrown if is public static IEnumerable> Subsets(this IEnumerable sequence) { @@ -72,17 +78,18 @@ public static IEnumerable> Subsets(this IEnumerable sequence) } /// - /// Returns a sequence of representing all - /// subsets of a given size that are part of the original sequence. In - /// mathematics, it is equivalent to the combinations or - /// k-subsets of a set. + /// Returns a sequence of representing all subsets of a given size + /// that are part of the original sequence. In mathematics, it is equivalent to the + /// combinations or k-subsets of a set. /// - /// Sequence for which to produce subsets - /// The size of the subsets to produce - /// The type of the elements in the sequence - /// A sequence of lists that represents of K-sized subsets of the original sequence + /// Sequence for which to produce subsets. + /// The size of the subsets to produce. + /// The type of the elements in the sequence. + /// + /// A sequence of lists that represents of K-sized subsets of the original + /// sequence. /// - /// Thrown if is + /// Thrown if is . /// /// /// Thrown if is less than zero. diff --git a/MoreLinq/Window.cs b/MoreLinq/Window.cs index 011793d1f..b7db91a85 100644 --- a/MoreLinq/Window.cs +++ b/MoreLinq/Window.cs @@ -23,16 +23,21 @@ namespace MoreLinq public static partial class MoreEnumerable { /// - /// Processes a sequence into a series of sub-sequences representing a windowed subset of the original + /// Processes a sequence into a series of sub-sequences representing a windowed subset of + /// the original. /// + /// The type of the elements of the source sequence. + /// The sequence to evaluate a sliding window over. + /// The size (number of elements) in each window. + /// + /// A series of sequences representing each sliding window subsequence. /// - /// The number of sequences returned is: Max(0, sequence.Count() - windowSize) + 1
- /// Returned sub-sequences are buffered, but the overall operation is streamed.
+ /// + /// The number of sequences returned is: Max(0, sequence.Count() - windowSize) + + /// 1 + /// + /// Returned sub-sequences are buffered, but the overall operation is streamed. /// - /// The type of the elements of the source sequence - /// The sequence to evaluate a sliding window over - /// The size (number of elements) in each window - /// A series of sequences representing each sliding window subsequence public static IEnumerable> Window(this IEnumerable source, int size) { @@ -70,16 +75,20 @@ public static IEnumerable> Window(this IEnumerable - /// Processes a sequence into a series of sub-sequences representing a windowed subset of the original + /// Processes a sequence into a series of sub-sequences representing a windowed subset of the original. /// + /// The type of the elements of the source sequence. + /// The sequence to evaluate a sliding window over. + /// The size (number of elements) in each window. + /// + /// A series of sequences representing each sliding window subsequence. /// - /// The number of sequences returned is: Max(0, sequence.Count() - windowSize) + 1
- /// Returned sub-sequences are buffered, but the overall operation is streamed.
+ /// + /// The number of sequences returned is: Max(0, sequence.Count() - windowSize) + + /// 1 + /// + /// Returned sub-sequences are buffered, but the overall operation is streamed. /// - /// The type of the elements of the source sequence - /// The sequence to evaluate a sliding window over - /// The size (number of elements) in each window - /// A series of sequences representing each sliding window subsequence [Obsolete("Use " + nameof(Window) + " instead.")] public static IEnumerable> Windowed(this IEnumerable source, int size) => From 284b5e3581057b155c2eca23e7e9514d8b0c62d4 Mon Sep 17 00:00:00 2001 From: Bar Arnon Date: Mon, 30 Jan 2023 19:04:57 +0200 Subject: [PATCH 062/157] Fix "Debug.Assert" to use condition expression as message --- MoreLinq/Debug.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/MoreLinq/Debug.cs b/MoreLinq/Debug.cs index 6b36c21c7..44d758c38 100644 --- a/MoreLinq/Debug.cs +++ b/MoreLinq/Debug.cs @@ -26,6 +26,6 @@ static class Debug [Conditional("DEBUG")] public static void Assert([DoesNotReturnIf(false)] bool condition, [CallerArgumentExpression(nameof(condition))] string? message = null) => - System.Diagnostics.Debug.Assert(condition); + System.Diagnostics.Debug.Assert(condition, message); } } From 4a9041d27bdce928199deb0c4a3c55af2fb1a1de Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 30 Jan 2023 19:08:17 +0100 Subject: [PATCH 063/157] Prepare for 3.4 --- MoreLinq/MoreLinq.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 50b11a3aa..a61b9b67c 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -117,7 +117,7 @@ $([System.Text.RegularExpressions.Regex]::Replace($(Copyright), `\s+`, ` `).Trim()) MoreLINQ en-US - 3.3.2 + 3.4.0 MoreLINQ Developers. net462;netstandard1.0;netstandard2.0;netstandard2.1;net6.0 portable From 02627a58c21db2fc72581c9450e63ba9d3b1f7c3 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 9 Feb 2023 23:23:47 +0100 Subject: [PATCH 064/157] Fix formatting in experimental "Batch" overloads [ci skip] --- MoreLinq/Experimental/Batch.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/MoreLinq/Experimental/Batch.cs b/MoreLinq/Experimental/Batch.cs index 49bb1f3f4..ee25e1619 100644 --- a/MoreLinq/Experimental/Batch.cs +++ b/MoreLinq/Experimental/Batch.cs @@ -168,7 +168,7 @@ ICurrentBufferProvider Cursor(IEnumerator<(T[], int)> source) => { case ICollection { Count: 0 }: { - return Cursor(Enumerable.Empty <(T[], int)>().GetEnumerator()); + return Cursor(Enumerable.Empty<(T[], int)>().GetEnumerator()); } case ICollection collection when collection.Count <= size: { @@ -178,7 +178,7 @@ ICurrentBufferProvider Cursor(IEnumerator<(T[], int)> source) => } case IReadOnlyCollection { Count: 0 }: { - return Cursor(Enumerable.Empty <(T[], int)>().GetEnumerator()); + return Cursor(Enumerable.Empty<(T[], int)>().GetEnumerator()); } case IReadOnlyList list when list.Count <= size: { From d2217ce17d1e5526c06bc3d5b67f60c5beae9d2b Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 18 Feb 2023 16:51:22 +0100 Subject: [PATCH 065/157] Use compiler-generated delegate caches in "ToDelimitedString" --- MoreLinq/ToDelimitedString.g.cs | 101 +++++--------------------------- MoreLinq/ToDelimitedString.g.tt | 15 ++--- 2 files changed, 18 insertions(+), 98 deletions(-) diff --git a/MoreLinq/ToDelimitedString.g.cs b/MoreLinq/ToDelimitedString.g.cs index ef651e469..17ba8f8e0 100644 --- a/MoreLinq/ToDelimitedString.g.cs +++ b/MoreLinq/ToDelimitedString.g.cs @@ -57,12 +57,7 @@ public static string ToDelimitedString(this IEnumerable source, string del { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.Boolean); - } - - static partial class StringBuilderAppenders - { - public static readonly Func Boolean = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } /// @@ -88,12 +83,7 @@ public static string ToDelimitedString(this IEnumerable source, string del { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.Byte); - } - - static partial class StringBuilderAppenders - { - public static readonly Func Byte = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } /// @@ -119,12 +109,7 @@ public static string ToDelimitedString(this IEnumerable source, string del { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.Char); - } - - static partial class StringBuilderAppenders - { - public static readonly Func Char = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } /// @@ -150,12 +135,7 @@ public static string ToDelimitedString(this IEnumerable source, string { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.Decimal); - } - - static partial class StringBuilderAppenders - { - public static readonly Func Decimal = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } /// @@ -181,12 +161,7 @@ public static string ToDelimitedString(this IEnumerable source, string d { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.Double); - } - - static partial class StringBuilderAppenders - { - public static readonly Func Double = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } /// @@ -212,12 +187,7 @@ public static string ToDelimitedString(this IEnumerable source, string de { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.Single); - } - - static partial class StringBuilderAppenders - { - public static readonly Func Single = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } /// @@ -243,12 +213,7 @@ public static string ToDelimitedString(this IEnumerable source, string deli { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.Int32); - } - - static partial class StringBuilderAppenders - { - public static readonly Func Int32 = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } /// @@ -274,12 +239,7 @@ public static string ToDelimitedString(this IEnumerable source, string del { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.Int64); - } - - static partial class StringBuilderAppenders - { - public static readonly Func Int64 = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } /// @@ -305,12 +265,7 @@ public static string ToDelimitedString(this IEnumerable source, string de { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.SByte); - } - - static partial class StringBuilderAppenders - { - public static readonly Func SByte = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } /// @@ -336,12 +291,7 @@ public static string ToDelimitedString(this IEnumerable source, string de { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.Int16); - } - - static partial class StringBuilderAppenders - { - public static readonly Func Int16 = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } /// @@ -367,12 +317,7 @@ public static string ToDelimitedString(this IEnumerable source, string d { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.String); - } - - static partial class StringBuilderAppenders - { - public static readonly Func String = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } /// @@ -398,12 +343,7 @@ public static string ToDelimitedString(this IEnumerable source, string del { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.UInt32); - } - - static partial class StringBuilderAppenders - { - public static readonly Func UInt32 = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } /// @@ -429,12 +369,7 @@ public static string ToDelimitedString(this IEnumerable source, string de { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.UInt64); - } - - static partial class StringBuilderAppenders - { - public static readonly Func UInt64 = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } /// @@ -460,15 +395,7 @@ public static string ToDelimitedString(this IEnumerable source, string d { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.UInt16); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } - - static partial class StringBuilderAppenders - { - public static readonly Func UInt16 = (sb, e) => sb.Append(e); - } - - - static partial class StringBuilderAppenders {} } } diff --git a/MoreLinq/ToDelimitedString.g.tt b/MoreLinq/ToDelimitedString.g.tt index 8f2c6a2d7..cbf2bcd13 100644 --- a/MoreLinq/ToDelimitedString.g.tt +++ b/MoreLinq/ToDelimitedString.g.tt @@ -42,8 +42,8 @@ namespace MoreLinq using System.Text; partial class MoreEnumerable - { -<# var cscp = new CSharpCodeProvider(); + {<# + var cscp = new CSharpCodeProvider(); var types = from method in typeof(StringBuilder).GetMethods(BindingFlags.Public | BindingFlags.Instance) where "Append" == method.Name @@ -73,6 +73,7 @@ namespace MoreLinq break; } #> + /// /// Creates a delimited string from a sequence of values and /// a given delimiter. @@ -96,16 +97,8 @@ namespace MoreLinq { if (source == null) throw new ArgumentNullException(nameof(source)); if (delimiter == null) throw new ArgumentNullException(nameof(delimiter)); - return ToDelimitedStringImpl(source, delimiter, StringBuilderAppenders.<#= type.Type.Name #>); - } - - static partial class StringBuilderAppenders - { - public static readonly Func, StringBuilder> <#= type.Type.Name #> = (sb, e) => sb.Append(e); + return ToDelimitedStringImpl(source, delimiter, static (sb, e) => sb.Append(e)); } - <# } #> - - static partial class StringBuilderAppenders {} } } From b7117086d3fa98c619cfc93477ed2659c1fcf418 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Fri, 17 Feb 2023 09:38:45 +0100 Subject: [PATCH 066/157] Simplify switch in T4 template for "ToDelimitedString" --- MoreLinq/ToDelimitedString.g.tt | 29 ++++++++++------------------- 1 file changed, 10 insertions(+), 19 deletions(-) diff --git a/MoreLinq/ToDelimitedString.g.tt b/MoreLinq/ToDelimitedString.g.tt index cbf2bcd13..ba38008de 100644 --- a/MoreLinq/ToDelimitedString.g.tt +++ b/MoreLinq/ToDelimitedString.g.tt @@ -52,26 +52,17 @@ namespace MoreLinq select parameters.First().ParameterType into type where !type.IsGenericType // e.g. ReadOnlySpan<> && (type.IsValueType || type == typeof(string)) - let res = new + select cscp.GetTypeOutput(new CodeTypeReference(type)) into builtInName + select new { - Type = type, - Name = cscp.GetTypeOutput(new CodeTypeReference(type)), - } - orderby res.Name - select res; - foreach (var type in types) { - string attribute; - switch(type.Name.ToLowerInvariant()) { - case "sbyte": - case "ulong": - case "ushort": - case "uint": - attribute = " [CLSCompliant(false)]"; - break; - default: - attribute = ""; - break; + Name = builtInName, + IsNotClsCompliant = builtInName is "sbyte" or "ulong" or "ushort" or "uint", } + into type + orderby type.Name + select type; + foreach (var type in types) + { #> /// @@ -92,7 +83,7 @@ namespace MoreLinq /// /// This operator uses immediate execution and effectively buffers the sequence. /// -<#= attribute #> +<#= type.IsNotClsCompliant ? " [CLSCompliant(false)]" : string.Empty #> public static string ToDelimitedString(this IEnumerable<<#= type.Name #>> source, string delimiter) { if (source == null) throw new ArgumentNullException(nameof(source)); From 1ef37538427c824b684c13404f748dbb8762af27 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 25 Feb 2023 17:16:27 +0100 Subject: [PATCH 067/157] Add "Merge"; merges sequence of async streams into one --- MoreLinq.Test/.editorconfig | 3 + MoreLinq.Test/Async/MergeTest.cs | 161 ++++++++++++ MoreLinq.Test/Async/TestExtensions.cs | 60 +++++ MoreLinq.Test/Async/TestingAsyncSequence.cs | 115 ++++++++ MoreLinq.Test/Async/WatchableEnumerator.cs | 54 ++++ .../Async/ExperimentalEnumerable.cs | 24 ++ MoreLinq/Experimental/Async/Merge.cs | 247 ++++++++++++++++++ MoreLinq/MoreLinq.csproj | 5 +- README.md | 8 + 9 files changed, 675 insertions(+), 2 deletions(-) create mode 100644 MoreLinq.Test/Async/MergeTest.cs create mode 100644 MoreLinq.Test/Async/TestExtensions.cs create mode 100644 MoreLinq.Test/Async/TestingAsyncSequence.cs create mode 100644 MoreLinq.Test/Async/WatchableEnumerator.cs create mode 100644 MoreLinq/Experimental/Async/ExperimentalEnumerable.cs create mode 100644 MoreLinq/Experimental/Async/Merge.cs diff --git a/MoreLinq.Test/.editorconfig b/MoreLinq.Test/.editorconfig index 7132855c0..d9548d45a 100644 --- a/MoreLinq.Test/.editorconfig +++ b/MoreLinq.Test/.editorconfig @@ -27,6 +27,9 @@ dotnet_diagnostic.CA1707.severity = none # CA1308: Normalize strings to uppercase dotnet_diagnostic.CA1308.severity = none +# CA2007: Consider calling ConfigureAwait on the awaited task +dotnet_diagnostic.CA2007.severity = suggestion + # IDE0047: Remove unnecessary parentheses dotnet_diagnostic.IDE0047.severity = suggestion diff --git a/MoreLinq.Test/Async/MergeTest.cs b/MoreLinq.Test/Async/MergeTest.cs new file mode 100644 index 000000000..81bbc18b8 --- /dev/null +++ b/MoreLinq.Test/Async/MergeTest.cs @@ -0,0 +1,161 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2020 Atif Aziz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq.Test.Async +{ + using System; + using System.Collections.Generic; + using System.Threading.Tasks; + using Experimental.Async; + using NUnit.Framework; + using Throws = Throws; + + [TestFixture] + public class MergeTest + { + [TestCase(0)] + [TestCase(-1)] + [TestCase(-2)] + [TestCase(-3)] + public void InvalidMaxConcurrent(int n) + { + var sources = new IAsyncEnumerable[0]; + void Act() => sources.Merge(n); + Assert.That(Act, Throws.ArgumentOutOfRangeException("maxConcurrent")); + } + + [Test] + public async Task MergeSync() + { + using var ts1 = AsyncEnumerable.Range(1, 1).AsTestingSequence(); + using var ts2 = AsyncEnumerable.Range(1, 2).AsTestingSequence(); + using var ts3 = AsyncEnumerable.Range(1, 3).AsTestingSequence(); + using var ts4 = AsyncEnumerable.Range(1, 4).AsTestingSequence(); + using var ts5 = AsyncEnumerable.Range(1, 5).AsTestingSequence(); + + using var ts = TestingSequence.Of(ts1, ts2, ts3, ts4, ts5); + var result = await ts.Merge().ToListAsync(); + + Assert.That(result, Is.EqualTo(new[] + { + 1, + 1, 2, + 1, 2, 3, + 1, 2, 3, 4, + 1, 2, 3, 4, 5, + })); + } + + [Test] + public async Task MergeAsyncAll() + { + using var ts1 = AsyncEnumerable.Range(10, 1).Yield().AsTestingSequence(); + using var ts2 = AsyncEnumerable.Range(20, 2).Yield().AsTestingSequence(); + using var ts3 = AsyncEnumerable.Range(30, 3).Yield().AsTestingSequence(); + using var ts4 = AsyncEnumerable.Range(40, 4).Yield().AsTestingSequence(); + using var ts5 = AsyncEnumerable.Range(50, 5).Yield().AsTestingSequence(); + + using var ts = TestingSequence.Of(ts1, ts2, ts3, ts4, ts5); + var result = await ts.Merge().ToListAsync(); + + Assert.That(result, Is.EquivalentTo(new[] + { + 10, + 20, 21, + 30, 31, 32, + 40, 41, 42, 43, + 50, 51, 52, 53, 54, + })); + } + + sealed class AsyncControl + { + sealed record State(TaskCompletionSource TaskCompletionSource, T Result); + + State? _state; + + public Task Result(T result) + { + if (_state is not null) + throw new InvalidOperationException(); + _state = new State(new TaskCompletionSource(), result); + return _state.TaskCompletionSource.Task; + } + + public void Complete() + { + if (_state is not { } state) + throw new InvalidOperationException(); + _state = null; + state.TaskCompletionSource.SetResult(state.Result); + } + } + + [Test] + public async Task MergeAsyncSome() + { + var ac1 = new AsyncControl(); + var ac2 = new AsyncControl(); + + async IAsyncEnumerable Source1() + { + yield return await ac1.Result(1); + yield return 2; + yield return 3; + _ = await ac1.Result(0); + } + + async IAsyncEnumerable Source2() + { + yield return await ac2.Result(4); + } + + using var ts1 = Source1().AsTestingSequence(); + using var ts2 = Source2().AsTestingSequence(); + using var sources = TestingSequence.Of(ts1, ts2); + var e = sources.Merge().GetAsyncEnumerator(); + + async Task ExpectAsync(AsyncControl control) + { + var t = e.MoveNextAsync(); + Assert.That(t.IsCompleted, Is.False); + control.Complete(); + Assert.That(await t, Is.True); + return e.Current; + } + + async Task ExpectSync() + { + var t = e.MoveNextAsync(); + Assert.That(t.IsCompleted, Is.True); + Assert.That(await t, Is.True); + return e.Current; + } + + Assert.That(await ExpectAsync(ac2), Is.EqualTo(4)); + Assert.That(await ExpectAsync(ac1), Is.EqualTo(1)); + Assert.That(ts2.IsDisposed, Is.True); + Assert.That(await ExpectSync(), Is.EqualTo(2)); + Assert.That(await ExpectSync(), Is.EqualTo(3)); + + var t = e.MoveNextAsync(); + Assert.That(t.IsCompleted, Is.False); + ac1.Complete(); + Assert.That(await t, Is.False); + } + } +} diff --git a/MoreLinq.Test/Async/TestExtensions.cs b/MoreLinq.Test/Async/TestExtensions.cs new file mode 100644 index 000000000..0636fabaf --- /dev/null +++ b/MoreLinq.Test/Async/TestExtensions.cs @@ -0,0 +1,60 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2020 Atif Aziz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq.Test.Async +{ + using System; + using System.Collections.Generic; + using System.Runtime.CompilerServices; + using System.Threading; + using System.Threading.Tasks; + + static partial class TestExtensions + { + public static IAsyncEnumerable Yield(this IAsyncEnumerable source) => + Yield(source, _ => true); + + public static IAsyncEnumerable + Yield(this IAsyncEnumerable source, + Func predicate) => + Yield(source, shouldEndSynchronously: false, predicate); + + public static IAsyncEnumerable + Yield(this IAsyncEnumerable source, + bool shouldEndSynchronously, + Func predicate) + { + if (source is null) throw new ArgumentNullException(nameof(source)); + if (predicate is null) throw new ArgumentNullException(nameof(predicate)); + + return Async(); + + async IAsyncEnumerable Async([EnumeratorCancellation]CancellationToken cancellationToken = default) + { + await foreach (var item in source.WithCancellation(cancellationToken)) + { + if (predicate(item)) + await Task.Yield(); + yield return item; + } + + if (!shouldEndSynchronously) + await Task.Yield(); + } + } + } +} diff --git a/MoreLinq.Test/Async/TestingAsyncSequence.cs b/MoreLinq.Test/Async/TestingAsyncSequence.cs new file mode 100644 index 000000000..e63f2227e --- /dev/null +++ b/MoreLinq.Test/Async/TestingAsyncSequence.cs @@ -0,0 +1,115 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2009 Atif Aziz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq.Test.Async +{ + using System; + using System.Collections.Generic; + using System.Linq; + using System.Runtime.ExceptionServices; + using System.Threading; + using NUnit.Framework; + + static class TestingAsyncSequence + { + public static TestingAsyncSequence Of(params T[] elements) => + new(elements.ToAsyncEnumerable()); + + public static TestingAsyncSequence AsTestingSequence(this IAsyncEnumerable source) => + source is not null + ? new TestingAsyncSequence(source) + : throw new ArgumentNullException(nameof(source)); + } + + /// + /// Sequence that asserts whether its iterator has been disposed + /// when it is disposed itself and also whether GetEnumerator() is + /// called exactly once or not. + /// + + sealed class TestingAsyncSequence : IAsyncEnumerable, IDisposable + { + bool? _disposed; + IAsyncEnumerable? _source; + ExceptionDispatchInfo? _disposeErrorInfo; + + internal TestingAsyncSequence(IAsyncEnumerable sequence) => + _source = sequence; + + public bool IsDisposed => _disposed == true; + public int MoveNextCallCount { get; private set; } + + void IDisposable.Dispose() => + AssertDisposed(); + + /// + /// Checks that the iterator was disposed, and then resets. + /// + + void AssertDisposed() + { + _disposeErrorInfo?.Throw(); + + if (_disposed is null) + return; + + Assert.IsTrue(_disposed, "Expected sequence to be disposed."); + _disposed = null; + } + + public IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) + { + Assert.That(_source, Is.Not.Null, + "LINQ operators should not enumerate a sequence more than once."); + + // Dammit (!) below is okay since we assert above it's not null. + var enumerator = _source!.GetAsyncEnumerator(cancellationToken).AsWatchable(); + + _disposed = false; + enumerator.Disposed += delegate + { + // If the following assertion fails the capture the error + // and re-throw later during the disposal of the test + // sequence. This is done so because "DisposeAsync" is never + // expected to throw and could interfere with how an operator + // builds on that assumption. + + try + { + Assert.That(_disposed, Is.False, "LINQ operators should not dispose a sequence more than once."); + } + catch (AssertionException e) + { + _disposeErrorInfo = ExceptionDispatchInfo.Capture(e); + } + + _disposed = true; + }; + + var ended = false; + enumerator.MoveNextCalled += (_, moved) => + { + Assert.That(ended, Is.False, "LINQ operators should not continue iterating a sequence that has terminated."); + ended = !moved; + MoveNextCallCount++; + }; + + _source = null; + return enumerator; + } + } +} diff --git a/MoreLinq.Test/Async/WatchableEnumerator.cs b/MoreLinq.Test/Async/WatchableEnumerator.cs new file mode 100644 index 000000000..0920b36e2 --- /dev/null +++ b/MoreLinq.Test/Async/WatchableEnumerator.cs @@ -0,0 +1,54 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2021 Atif Aziz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq.Test.Async +{ + using System; + using System.Collections.Generic; + using System.Threading.Tasks; + + partial class TestExtensions + { + public static WatchableEnumerator AsWatchable(this IAsyncEnumerator source) => new(source); + } + + sealed class WatchableEnumerator : IAsyncEnumerator + { + readonly IAsyncEnumerator _source; + + public event EventHandler? Disposed; + public event EventHandler? MoveNextCalled; + + public WatchableEnumerator(IAsyncEnumerator source) => + _source = source ?? throw new ArgumentNullException(nameof(source)); + + public T Current => _source.Current; + + public async ValueTask MoveNextAsync() + { + var moved = await _source.MoveNextAsync(); + MoveNextCalled?.Invoke(this, moved); + return moved; + } + + public async ValueTask DisposeAsync() + { + await _source.DisposeAsync(); + Disposed?.Invoke(this, EventArgs.Empty); + } + } +} diff --git a/MoreLinq/Experimental/Async/ExperimentalEnumerable.cs b/MoreLinq/Experimental/Async/ExperimentalEnumerable.cs new file mode 100644 index 000000000..542a35fb9 --- /dev/null +++ b/MoreLinq/Experimental/Async/ExperimentalEnumerable.cs @@ -0,0 +1,24 @@ +#if !NO_ASYNC_STREAMS + +namespace MoreLinq.Experimental.Async +{ + using System.Collections.Generic; + + /// + /// + /// Provides a set of static methods for querying objects that + /// implement . + /// + /// THE METHODS ARE EXPERIMENTAL. THEY MAY BE UNSTABLE AND + /// UNTESTED. THEY MAY BE REMOVED FROM A FUTURE MAJOR OR MINOR RELEASE AND + /// POSSIBLY WITHOUT NOTICE. USE THEM AT YOUR OWN RISK. THE METHODS ARE + /// PUBLISHED FOR FIELD EXPERIMENTATION TO SOLICIT FEEDBACK ON THEIR + /// UTILITY AND DESIGN/IMPLEMENTATION DEFECTS. + /// + + public static partial class ExperimentalEnumerable + { + } +} + +#endif // !NO_ASYNC_STREAMS diff --git a/MoreLinq/Experimental/Async/Merge.cs b/MoreLinq/Experimental/Async/Merge.cs new file mode 100644 index 000000000..34130abef --- /dev/null +++ b/MoreLinq/Experimental/Async/Merge.cs @@ -0,0 +1,247 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2020 Atif Aziz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +#if !NO_ASYNC_STREAMS + +namespace MoreLinq.Experimental.Async +{ + using System; + using System.Collections.Generic; + using System.Linq; + using System.Runtime.CompilerServices; + using System.Threading; + using System.Threading.Tasks; + + partial class ExperimentalEnumerable + { + /// + /// Concurrently merges all the elements of multiple asynchronous streams into a single + /// asynchronous stream. + /// + /// + /// The type of the elements in . + /// The sequence of asynchronous streams. + /// + /// An asynchronous stream with all elements from all . + /// + /// + /// This operator uses deferred execution and streams its results. + /// + /// The elements in the resulting stream may appear in a different order than their order in + /// . + /// + /// When disposed part of the way, there is a best-effort attempt to cancel all iterations + /// that are in flight. This requires that all asynchronous streams in properly honour timely cancellation. + /// + + public static IAsyncEnumerable Merge(this IEnumerable> sources) => + Merge(sources, int.MaxValue); + + /// + /// Concurrently merges all the elements of multiple asynchronous streams into a single + /// asynchronous stream. An additional parameter specifies the maximum concurrent operations + /// that may be in flight at any give time. + /// + /// + /// The type of the elements in . + /// The sequence of asynchronous streams. + /// + /// Maximum number of asynchronous operations to have in flight at any given time. A value + /// of 1 (or below) disables concurrency. + /// + /// An asynchronous stream with all elements from all . + /// + /// + /// + /// This operator uses deferred execution and streams its results. + /// + /// When is 2 or greater then the elements in the resulting + /// stream may appear in a different order than their order in . + /// + /// When disposed part of the way, there is a best-effort attempt to cancel all iterations + /// that are in flight. This requires that all asynchronous streams in properly honour timely cancellation. + /// + + public static IAsyncEnumerable Merge(this IEnumerable> sources, + int maxConcurrent) + { + if (sources is null) throw new ArgumentNullException(nameof(sources)); + if (maxConcurrent <= 0) throw new ArgumentOutOfRangeException(nameof(maxConcurrent)); + + return Async(); + + async IAsyncEnumerable Async([EnumeratorCancellation]CancellationToken cancellationToken = default) + { + using var thisCancellationTokenSource = new CancellationTokenSource(); + + using var cancellationTokenSource = + cancellationToken.CanBeCanceled + ? CancellationTokenSource.CreateLinkedTokenSource(thisCancellationTokenSource.Token, cancellationToken) + : thisCancellationTokenSource; + + cancellationToken = cancellationTokenSource.Token; + + var enumeratorList = new List>(); + var disposalTaskList = (List?)null; + var pendingTaskList = (List)>>?)null; + + try + { + enumeratorList.AddRange(from s in sources + select s.GetAsyncEnumerator(cancellationToken)); + + pendingTaskList = new List)>>(); + + const bool some = true; + + ValueTask? DisposeAsync(IAsyncEnumerator enumerator) + { + _ = enumeratorList.Remove(enumerator); + var disposalTask = enumerator.DisposeAsync(); + if (disposalTask.IsCompleted) + return disposalTask; + disposalTaskList ??= new List(); + disposalTaskList.Add(disposalTask.AsTask()); + return null; + } + + async ValueTask<(bool, T)> ReadAsync(IAsyncEnumerator enumerator) + { + var task = enumerator.MoveNextAsync(); + + if (task.IsCompleted) + { + if (await task.ConfigureAwait(false)) + return (some, enumerator.Current); + + if (DisposeAsync(enumerator) is { IsCompleted: true } completedDisposalTask) + await completedDisposalTask.ConfigureAwait(false); + } + else + { + pendingTaskList.Add(task.And(enumerator).AsTask()); + } + + return default; + } + + while (enumeratorList.Count > 0) + { + while (pendingTaskList.Count is var ptc + && ptc < enumeratorList.Count + && ptc < maxConcurrent) + { + var i = pendingTaskList.Count; + var enumerator = enumeratorList[i]; + + while (await ReadAsync(enumerator).ConfigureAwait(false) is (some, var item)) + yield return item; + } + + while (pendingTaskList.Count > 0) + { + var completedTask = await Task.WhenAny(pendingTaskList).ConfigureAwait(false); + var (moved, enumerator) = await completedTask.ConfigureAwait(false); + _ = pendingTaskList.Remove(completedTask); + + if (moved) + { + yield return enumerator.Current; + + while (await ReadAsync(enumerator).ConfigureAwait(false) is (some, var item)) + yield return item; + } + else if (DisposeAsync(enumerator) is { IsCompleted: true } completedDisposalTask) + { + await completedDisposalTask.ConfigureAwait(false); + } + } + } + } + finally + { + // Signal cancellation to those in flight. Unfortunately, this relies on all + // iterators to honour the cancellation. + + thisCancellationTokenSource.Cancel(); + + // > The caller of an async-iterator method should only call `DisposeAsync()` + // > when the method completed or was suspended by a `yield return`. + // + // Source: https://github.com/dotnet/roslyn/blob/0e7b657bf6c019ec8019dcbd4f833f0dda50a97d/docs/features/async-streams.md#disposal + // + // > The result of invoking `DisposeAsync` from states -1 or N is unspecified. + // > This compiler generates `throw new NotSupportException()` for those cases. + // + // Source: https://github.com/dotnet/roslyn/blob/0e7b657bf6c019ec8019dcbd4f833f0dda50a97d/docs/features/async-streams.md#state-values-and-transitions + // + // As a result, wait for all pending tasks to complete, irrespective of how they + // complete (successfully, faulted or canceled). The goal is that the iterator + // is in some defined state before disposing it otherwise it could throw + // "NotSupportedException". + + if (pendingTaskList is { Count: > 0 }) + { + while (await Task.WhenAny(pendingTaskList) + .ConfigureAwait(false) is { } completedTask) + { + _ = pendingTaskList.Remove(completedTask); + } + } + + foreach (var enumerator in enumeratorList) + { + ValueTask task; + + try + { + task = enumerator.DisposeAsync(); + } + catch (NotSupportedException) + { + // Ignore just in case we hit an unspecified case; + // see quoted notes from Roslyn spec above. + + continue; + } + + if (task.IsCompleted) + { + await task.ConfigureAwait(false); + } + else + { + disposalTaskList ??= new List(); + disposalTaskList.Add(task.AsTask()); + } + } + + if (disposalTaskList is { Count: > 0 }) + await Task.WhenAll(disposalTaskList).ConfigureAwait(false); + } + } + } + + static async ValueTask<(T1, T2)> And(this ValueTask task, T2 second) => + (await task.ConfigureAwait(false), second); + } +} + +#endif // !NO_ASYNC_STREAMS diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index a61b9b67c..a34d230da 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -54,6 +54,7 @@ - LeftJoin - MaxBy - Memoize (EXPERIMENTAL) + - Merge (EXPERIMENTAL) - MinBy - Move - OrderBy @@ -189,11 +190,11 @@ - $(DefineConstants);NO_BUFFERS + $(DefineConstants);NO_ASYNC_STREAMS;NO_BUFFERS - $(DefineConstants);NO_BUFFERS;NO_SERIALIZATION_ATTRIBUTES;NO_EXCEPTION_SERIALIZATION;NO_TRACING;NO_COM;NO_ASYNC + $(DefineConstants);NO_ASYNC_STREAMS;NO_BUFFERS;NO_SERIALIZATION_ATTRIBUTES;NO_EXCEPTION_SERIALIZATION;NO_TRACING;NO_COM;NO_ASYNC diff --git a/README.md b/README.md index e3ba59bb4..ece3287fc 100644 --- a/README.md +++ b/README.md @@ -755,6 +755,14 @@ Creates a sequence that lazily caches the source as it is iterated for the first time, reusing the cache thereafter for future re-iterations. If the source is already cached or buffered then it is returned verbatim. +### Merge + +Concurrently merges all the elements of multiple asynchronous streams into a +single asynchronous stream. An overload with an additional parameter specifies +the maximum concurrent operations that may be in flight at any give time. + +This method has 2 overloads. + ### TrySingle Returns the only element of a sequence that has just one element. If the From aefa90b55b01c437b1e86dee055f6c799997f548 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 25 Feb 2023 18:39:15 +0100 Subject: [PATCH 068/157] Update .NET SDK to 7.0.200 --- MoreLinq/ToDataTable.cs | 5 +---- global.json | 2 +- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/MoreLinq/ToDataTable.cs b/MoreLinq/ToDataTable.cs index af24eebb0..491ec8ca6 100644 --- a/MoreLinq/ToDataTable.cs +++ b/MoreLinq/ToDataTable.cs @@ -220,10 +220,7 @@ static MemberInfo[] BuildOrBindSchema(DataTable table, MemberInfo[] members) foreach (var info in schemas) { var member = info.Member; - var column = info.Column; - - if (column == null) - throw new ArgumentException($"Column named '{member.Name}' is missing.", nameof(table)); + var column = info.Column ?? throw new ArgumentException($"Column named '{member.Name}' is missing.", nameof(table)); if (info.Type != column.DataType) throw new ArgumentException($"Column named '{member.Name}' has wrong data type. It should be {info.Type} when it is {column.DataType}.", nameof(table)); diff --git a/global.json b/global.json index 77c776f82..5bf3e71b6 100644 --- a/global.json +++ b/global.json @@ -1,6 +1,6 @@ { "sdk": { - "version": "7.0.100", + "version": "7.0.200", "rollForward": "latestFeature" } } From 0addfbd5673d0d04056709b62a6ad03ca4ba5315 Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Sun, 26 Feb 2023 07:18:57 -0600 Subject: [PATCH 069/157] Fix "Batch" to optimise for collections at iteration-time This is a squashed merge of PR #965 that adds to issue #943. Co-authored-by: Atif Aziz --- MoreLinq.Test/BatchTest.cs | 16 ++++++ MoreLinq.Test/TestExtensions.cs | 17 +++++-- MoreLinq/Batch.cs | 86 ++++++++++++++++----------------- 3 files changed, 70 insertions(+), 49 deletions(-) diff --git a/MoreLinq.Test/BatchTest.cs b/MoreLinq.Test/BatchTest.cs index ca71e9938..bd2db7127 100644 --- a/MoreLinq.Test/BatchTest.cs +++ b/MoreLinq.Test/BatchTest.cs @@ -133,6 +133,22 @@ public void BatchEmptySource(SourceKind kind) var batches = Enumerable.Empty().ToSourceKind(kind).Batch(100); Assert.That(batches, Is.Empty); } + + [TestCase(SourceKind.BreakingList)] + [TestCase(SourceKind.BreakingReadOnlyList)] + [TestCase(SourceKind.BreakingCollection)] + public void BatchUsesCollectionCountAtIterationTime(SourceKind kind) + { + var list = new List { 1, 2 }; + var result = list.AsSourceKind(kind).Batch(3); + + list.Add(3); + result.AssertSequenceEqual(new[] { 1, 2, 3 }); + + list.Add(4); + // should fail trying to enumerate because count is now greater than the batch size + Assert.That(result.Consume, Throws.TypeOf()); + } } } diff --git a/MoreLinq.Test/TestExtensions.cs b/MoreLinq.Test/TestExtensions.cs index e327c09e8..706641f1b 100644 --- a/MoreLinq.Test/TestExtensions.cs +++ b/MoreLinq.Test/TestExtensions.cs @@ -88,13 +88,22 @@ internal static IEnumerable GenerateSplits(this string str, params char[ } internal static IEnumerable ToSourceKind(this IEnumerable input, SourceKind sourceKind) => +#pragma warning disable IDE0072 // Add missing cases sourceKind switch +#pragma warning restore IDE0072 // Add missing cases { SourceKind.Sequence => input.Select(x => x), - SourceKind.BreakingList => new BreakingList(input.ToList()), - SourceKind.BreakingReadOnlyList => new BreakingReadOnlyList(input.ToList()), - SourceKind.BreakingCollection => new BreakingCollection(input.ToList()), - SourceKind.BreakingReadOnlyCollection => new BreakingReadOnlyCollection(input.ToList()), + var kind => input.ToList().AsSourceKind(kind) + }; + + internal static IEnumerable AsSourceKind(this List input, SourceKind sourceKind) => + sourceKind switch + { + SourceKind.Sequence => input.Select(x => x), + SourceKind.BreakingList => new BreakingList(input), + SourceKind.BreakingReadOnlyList => new BreakingReadOnlyList(input), + SourceKind.BreakingCollection => new BreakingCollection(input), + SourceKind.BreakingReadOnlyCollection => new BreakingReadOnlyCollection(input), _ => throw new ArgumentException(null, nameof(sourceKind)) }; } diff --git a/MoreLinq/Batch.cs b/MoreLinq/Batch.cs index 5bb2553e7..b8abf7f1e 100644 --- a/MoreLinq/Batch.cs +++ b/MoreLinq/Batch.cs @@ -19,7 +19,6 @@ namespace MoreLinq { using System; using System.Collections.Generic; - using System.Linq; static partial class MoreEnumerable { @@ -87,69 +86,66 @@ public static IEnumerable Batch(this IEnumerable _() { - case ICollection { Count: 0 }: + switch (source) { - return Enumerable.Empty(); - } - case ICollection collection when collection.Count <= size: - { - return _(); IEnumerable _() + case ICollection { Count: 0 }: + { + break; + } + case ICollection collection when collection.Count <= size: { var bucket = new TSource[collection.Count]; collection.CopyTo(bucket, 0); yield return resultSelector(bucket); + break; } - } - case IReadOnlyCollection { Count: 0 }: - { - return Enumerable.Empty(); - } - case IReadOnlyList list when list.Count <= size: - { - return _(); IEnumerable _() + case IReadOnlyCollection { Count: 0 }: + { + break; + } + case IReadOnlyList list when list.Count <= size: { var bucket = new TSource[list.Count]; for (var i = 0; i < list.Count; i++) bucket[i] = list[i]; yield return resultSelector(bucket); + break; } - } - case IReadOnlyCollection collection when collection.Count <= size: - { - return Batch(collection.Count); - } - default: - { - return Batch(size); - } + case IReadOnlyCollection collection when collection.Count <= size: + { + size = collection.Count; + goto default; + } + default: + { + TSource[]? bucket = null; + var count = 0; - IEnumerable Batch(int size) - { - TSource[]? bucket = null; - var count = 0; + foreach (var item in source) + { + bucket ??= new TSource[size]; + bucket[count++] = item; - foreach (var item in source) - { - bucket ??= new TSource[size]; - bucket[count++] = item; + // The bucket is fully buffered before it's yielded + if (count != size) + continue; - // The bucket is fully buffered before it's yielded - if (count != size) - continue; + yield return resultSelector(bucket); - yield return resultSelector(bucket); + bucket = null; + count = 0; + } - bucket = null; - count = 0; - } + // Return the last bucket with all remaining elements + if (count > 0) + { + Array.Resize(ref bucket, count); + yield return resultSelector(bucket); + } - // Return the last bucket with all remaining elements - if (count > 0) - { - Array.Resize(ref bucket, count); - yield return resultSelector(bucket); + break; } } } From 76c37b3403d1e49c01dfec9a171528dace9b33eb Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Sun, 26 Feb 2023 12:44:58 -0600 Subject: [PATCH 070/157] Simplify "Fold" implementation Co-authored-by: Atif Aziz --- MoreLinq/Fold.cs | 64 +------------------------------ MoreLinq/Fold.g.cs | 96 ++++++++++++++++++++++++++++++++++++++-------- MoreLinq/Fold.g.tt | 11 ++++-- 3 files changed, 89 insertions(+), 82 deletions(-) diff --git a/MoreLinq/Fold.cs b/MoreLinq/Fold.cs index 93c2cefed..fde8568e5 100644 --- a/MoreLinq/Fold.cs +++ b/MoreLinq/Fold.cs @@ -22,73 +22,13 @@ namespace MoreLinq static partial class MoreEnumerable { - static TResult FoldImpl(IEnumerable source, int count, - Func? folder1 = null, - Func? folder2 = null, - Func? folder3 = null, - Func? folder4 = null, - Func? folder5 = null, - Func? folder6 = null, - Func? folder7 = null, - Func? folder8 = null, - Func? folder9 = null, - Func? folder10 = null, - Func? folder11 = null, - Func? folder12 = null, - Func? folder13 = null, - Func? folder14 = null, - Func? folder15 = null, - Func? folder16 = null - ) + static T[] Fold(this IEnumerable source, int count) { - if (source == null) throw new ArgumentNullException(nameof(source)); - if ( count == 1 && folder1 == null - || count == 2 && folder2 == null - || count == 3 && folder3 == null - || count == 4 && folder4 == null - || count == 5 && folder5 == null - || count == 6 && folder6 == null - || count == 7 && folder7 == null - || count == 8 && folder8 == null - || count == 9 && folder9 == null - || count == 10 && folder10 == null - || count == 11 && folder11 == null - || count == 12 && folder12 == null - || count == 13 && folder13 == null - || count == 14 && folder14 == null - || count == 15 && folder15 == null - || count == 16 && folder16 == null - ) - { // ReSharper disable NotResolvedInText -#pragma warning disable CA2208 // Instantiate argument exceptions correctly - throw new ArgumentNullException("folder"); // ReSharper restore NotResolvedInText -#pragma warning restore CA2208 // Instantiate argument exceptions correctly - } - var elements = new T[count]; foreach (var e in AssertCountImpl(source.Index(), count, OnFolderSourceSizeErrorSelector)) elements[e.Key] = e.Value; - return count switch - { - 1 => Assume.NotNull(folder1 )(elements[0]), - 2 => Assume.NotNull(folder2 )(elements[0], elements[1]), - 3 => Assume.NotNull(folder3 )(elements[0], elements[1], elements[2]), - 4 => Assume.NotNull(folder4 )(elements[0], elements[1], elements[2], elements[3]), - 5 => Assume.NotNull(folder5 )(elements[0], elements[1], elements[2], elements[3], elements[4]), - 6 => Assume.NotNull(folder6 )(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5]), - 7 => Assume.NotNull(folder7 )(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6]), - 8 => Assume.NotNull(folder8 )(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7]), - 9 => Assume.NotNull(folder9 )(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8]), - 10 => Assume.NotNull(folder10)(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9]), - 11 => Assume.NotNull(folder11)(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9], elements[10]), - 12 => Assume.NotNull(folder12)(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9], elements[10], elements[11]), - 13 => Assume.NotNull(folder13)(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9], elements[10], elements[11], elements[12]), - 14 => Assume.NotNull(folder14)(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9], elements[10], elements[11], elements[12], elements[13]), - 15 => Assume.NotNull(folder15)(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9], elements[10], elements[11], elements[12], elements[13], elements[14]), - 16 => Assume.NotNull(folder16)(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9], elements[10], elements[11], elements[12], elements[13], elements[14], elements[15]), - _ => throw new NotSupportedException() - }; + return elements; } static readonly Func OnFolderSourceSizeErrorSelector = OnFolderSourceSizeError; diff --git a/MoreLinq/Fold.g.cs b/MoreLinq/Fold.g.cs index 82f126067..09ebc01ce 100644 --- a/MoreLinq/Fold.g.cs +++ b/MoreLinq/Fold.g.cs @@ -41,7 +41,11 @@ partial class MoreEnumerable public static TResult Fold(this IEnumerable source, Func folder) { - return FoldImpl(source, 1, folder1: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(1); + return folder(elements[0]); } /// @@ -63,7 +67,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 2, folder2: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(2); + return folder(elements[0], elements[1]); } /// @@ -85,7 +93,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 3, folder3: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(3); + return folder(elements[0], elements[1], elements[2]); } /// @@ -107,7 +119,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 4, folder4: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(4); + return folder(elements[0], elements[1], elements[2], elements[3]); } /// @@ -129,7 +145,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 5, folder5: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(5); + return folder(elements[0], elements[1], elements[2], elements[3], elements[4]); } /// @@ -151,7 +171,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 6, folder6: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(6); + return folder(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5]); } /// @@ -173,7 +197,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 7, folder7: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(7); + return folder(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6]); } /// @@ -195,7 +223,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 8, folder8: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(8); + return folder(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7]); } /// @@ -217,7 +249,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 9, folder9: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(9); + return folder(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8]); } /// @@ -239,7 +275,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 10, folder10: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(10); + return folder(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9]); } /// @@ -261,7 +301,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 11, folder11: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(11); + return folder(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9], elements[10]); } /// @@ -283,7 +327,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 12, folder12: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(12); + return folder(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9], elements[10], elements[11]); } /// @@ -305,7 +353,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 13, folder13: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(13); + return folder(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9], elements[10], elements[11], elements[12]); } /// @@ -327,7 +379,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 14, folder14: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(14); + return folder(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9], elements[10], elements[11], elements[12], elements[13]); } /// @@ -349,7 +405,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 15, folder15: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(15); + return folder(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9], elements[10], elements[11], elements[12], elements[13], elements[14]); } /// @@ -371,7 +431,11 @@ public static TResult Fold(this IEnumerable source, Func(this IEnumerable source, Func folder) { - return FoldImpl(source, 16, folder16: folder); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(16); + return folder(elements[0], elements[1], elements[2], elements[3], elements[4], elements[5], elements[6], elements[7], elements[8], elements[9], elements[10], elements[11], elements[12], elements[13], elements[14], elements[15]); } } diff --git a/MoreLinq/Fold.g.tt b/MoreLinq/Fold.g.tt index 693af6088..7d5c3da54 100644 --- a/MoreLinq/Fold.g.tt +++ b/MoreLinq/Fold.g.tt @@ -34,11 +34,10 @@ namespace MoreLinq select new { Ts = string.Join(", ", Enumerable.Repeat("T", i)), - Count = i, CountElements = istr + " " + (i == 1 ? "element" : "elements"), CountArg = istr, - FolderArgs = "folder" + istr + ": folder", - + Elements = string.Join(", ", from j in Enumerable.Range(0, i) + select FormattableString.Invariant($"elements[{j}]")), }; foreach (var e in overloads) { #> @@ -61,7 +60,11 @@ namespace MoreLinq public static TResult Fold(this IEnumerable source, Func<<#= e.Ts #>, TResult> folder) { - return FoldImpl(source, <#= e.CountArg #>, <#= e.FolderArgs #>); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (folder == null) throw new ArgumentNullException(nameof(folder)); + + var elements = source.Fold(<#= e.CountArg #>); + return folder(<#= e.Elements #>); } <# } #> From b234b52f8141d5c5f9acfb476188bf898cfccb50 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 26 Feb 2023 21:42:08 +0100 Subject: [PATCH 071/157] Remove final blank line in generated "Fold" overloads --- MoreLinq/Fold.g.cs | 1 - MoreLinq/Fold.g.tt | 6 +++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/MoreLinq/Fold.g.cs b/MoreLinq/Fold.g.cs index 09ebc01ce..714c8f945 100644 --- a/MoreLinq/Fold.g.cs +++ b/MoreLinq/Fold.g.cs @@ -437,6 +437,5 @@ public static TResult Fold(this IEnumerable source, Func + /// /// Returns the result of applying a function to a sequence of /// <#= e.CountElements #>. @@ -66,7 +67,6 @@ namespace MoreLinq var elements = source.Fold(<#= e.CountArg #>); return folder(<#= e.Elements #>); } - <# } #> } } From 777aa2421ab55dd88bd883d044234585e2d86490 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 26 Feb 2023 21:52:18 +0100 Subject: [PATCH 072/157] Simplify "Fold" T4 template --- MoreLinq/Fold.g.tt | 28 +++++++++++++--------------- 1 file changed, 13 insertions(+), 15 deletions(-) diff --git a/MoreLinq/Fold.g.tt b/MoreLinq/Fold.g.tt index 3befdcc14..41a0a1205 100644 --- a/MoreLinq/Fold.g.tt +++ b/MoreLinq/Fold.g.tt @@ -29,22 +29,19 @@ namespace MoreLinq {<# const int max = 16; var overloads = - from i in Enumerable.Range(1, max) - let istr = i.ToString(CultureInfo.InvariantCulture) - select new - { - Ts = string.Join(", ", Enumerable.Repeat("T", i)), - CountElements = istr + " " + (i == 1 ? "element" : "elements"), - CountArg = istr, - Elements = string.Join(", ", from j in Enumerable.Range(0, i) - select FormattableString.Invariant($"elements[{j}]")), - }; + Enumerable.Range(1, max) + .Zip(Enumerable.Repeat("elements", max).Prepend("element"), (c, n) => new + { + Count = c, + CountString = c.ToString(CultureInfo.InvariantCulture), + ElementNoun = n + }); foreach (var e in overloads) { #> /// /// Returns the result of applying a function to a sequence of - /// <#= e.CountElements #>. + /// <#= e.CountString #> <#= e.ElementNoun #>. /// /// /// This operator uses immediate execution and effectively buffers @@ -57,15 +54,16 @@ namespace MoreLinq /// The folded value returned by . /// is null /// is null - /// does not contain exactly <#= e.CountElements #> + /// does not contain exactly <#= e.CountString #> <#= e.ElementNoun #> - public static TResult Fold(this IEnumerable source, Func<<#= e.Ts #>, TResult> folder) + public static TResult Fold(this IEnumerable source, Func<<#= string.Join(", ", Enumerable.Repeat("T", e.Count)) #>, TResult> folder) { if (source == null) throw new ArgumentNullException(nameof(source)); if (folder == null) throw new ArgumentNullException(nameof(folder)); - var elements = source.Fold(<#= e.CountArg #>); - return folder(<#= e.Elements #>); + var elements = source.Fold(<#= e.CountString #>); + return folder(<#= string.Join(", ", from i in Enumerable.Range(0, e.Count) + select FormattableString.Invariant($"elements[{i}]")) #>); } <# } #> } From f53c6727d3c17d5beb96bd806299153ac42f9b88 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 26 Feb 2023 23:32:34 +0100 Subject: [PATCH 073/157] Fix inconsistencies in "Fold" doc --- MoreLinq/Extensions.g.cs | 176 +++++++++++++++++++++------------------ MoreLinq/Fold.g.cs | 176 +++++++++++++++++++++------------------ MoreLinq/Fold.g.tt | 11 +-- 3 files changed, 198 insertions(+), 165 deletions(-) diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index a5ca2ac81..4ec625245 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -2032,14 +2032,15 @@ public static partial class FoldExtension /// This operator uses immediate execution and effectively buffers /// as many items of the source sequence as necessary. /// - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 1 element + /// + /// Either or is . + /// + /// does not contain exactly 1 element. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2052,14 +2053,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 2 elements + /// + /// Either or is . + /// + /// does not contain exactly 2 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2072,14 +2074,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 3 elements + /// + /// Either or is . + /// + /// does not contain exactly 3 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2092,14 +2095,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 4 elements + /// + /// Either or is . + /// + /// does not contain exactly 4 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2112,14 +2116,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 5 elements + /// + /// Either or is . + /// + /// does not contain exactly 5 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2132,14 +2137,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 6 elements + /// + /// Either or is . + /// + /// does not contain exactly 6 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2152,14 +2158,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 7 elements + /// + /// Either or is . + /// + /// does not contain exactly 7 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2172,14 +2179,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 8 elements + /// + /// Either or is . + /// + /// does not contain exactly 8 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2192,14 +2200,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 9 elements + /// + /// Either or is . + /// + /// does not contain exactly 9 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2212,14 +2221,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 10 elements + /// + /// Either or is . + /// + /// does not contain exactly 10 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2232,14 +2242,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 11 elements + /// + /// Either or is . + /// + /// does not contain exactly 11 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2252,14 +2263,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 12 elements + /// + /// Either or is . + /// + /// does not contain exactly 12 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2272,14 +2284,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 13 elements + /// + /// Either or is . + /// + /// does not contain exactly 13 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2292,14 +2305,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 14 elements + /// + /// Either or is . + /// + /// does not contain exactly 14 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2312,14 +2326,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 15 elements + /// + /// Either or is . + /// + /// does not contain exactly 15 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); @@ -2332,14 +2347,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 16 elements + /// + /// Either or is . + /// + /// does not contain exactly 16 elements. public static TResult Fold(this IEnumerable source, Func folder) => MoreEnumerable.Fold(source, folder); diff --git a/MoreLinq/Fold.g.cs b/MoreLinq/Fold.g.cs index 714c8f945..e7d64b884 100644 --- a/MoreLinq/Fold.g.cs +++ b/MoreLinq/Fold.g.cs @@ -30,14 +30,15 @@ partial class MoreEnumerable /// This operator uses immediate execution and effectively buffers /// as many items of the source sequence as necessary. /// - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 1 element + /// + /// Either or is . + /// + /// does not contain exactly 1 element. public static TResult Fold(this IEnumerable source, Func folder) { @@ -56,14 +57,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 2 elements + /// + /// Either or is . + /// + /// does not contain exactly 2 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -82,14 +84,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 3 elements + /// + /// Either or is . + /// + /// does not contain exactly 3 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -108,14 +111,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 4 elements + /// + /// Either or is . + /// + /// does not contain exactly 4 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -134,14 +138,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 5 elements + /// + /// Either or is . + /// + /// does not contain exactly 5 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -160,14 +165,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 6 elements + /// + /// Either or is . + /// + /// does not contain exactly 6 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -186,14 +192,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 7 elements + /// + /// Either or is . + /// + /// does not contain exactly 7 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -212,14 +219,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 8 elements + /// + /// Either or is . + /// + /// does not contain exactly 8 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -238,14 +246,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 9 elements + /// + /// Either or is . + /// + /// does not contain exactly 9 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -264,14 +273,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 10 elements + /// + /// Either or is . + /// + /// does not contain exactly 10 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -290,14 +300,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 11 elements + /// + /// Either or is . + /// + /// does not contain exactly 11 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -316,14 +327,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 12 elements + /// + /// Either or is . + /// + /// does not contain exactly 12 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -342,14 +354,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 13 elements + /// + /// Either or is . + /// + /// does not contain exactly 13 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -368,14 +381,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 14 elements + /// + /// Either or is . + /// + /// does not contain exactly 14 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -394,14 +408,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 15 elements + /// + /// Either or is . + /// + /// does not contain exactly 15 elements. public static TResult Fold(this IEnumerable source, Func folder) { @@ -420,14 +435,15 @@ public static TResult Fold(this IEnumerable source, Func - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly 16 elements + /// + /// Either or is . + /// + /// does not contain exactly 16 elements. public static TResult Fold(this IEnumerable source, Func folder) { diff --git a/MoreLinq/Fold.g.tt b/MoreLinq/Fold.g.tt index 41a0a1205..d5ce0fc74 100644 --- a/MoreLinq/Fold.g.tt +++ b/MoreLinq/Fold.g.tt @@ -47,14 +47,15 @@ namespace MoreLinq /// This operator uses immediate execution and effectively buffers /// as many items of the source sequence as necessary. /// - /// Type of element in the source sequence - /// Type of the result + /// Type of element in the source sequence. + /// Type of the result. /// The sequence of items to fold. /// Function to apply to the elements in the sequence. /// The folded value returned by . - /// is null - /// is null - /// does not contain exactly <#= e.CountString #> <#= e.ElementNoun #> + /// + /// Either or is . + /// + /// does not contain exactly <#= e.CountString #> <#= e.ElementNoun #>. public static TResult Fold(this IEnumerable source, Func<<#= string.Join(", ", Enumerable.Repeat("T", e.Count)) #>, TResult> folder) { From 62f043269006389c09308b22de98709971b14050 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 26 Feb 2023 23:47:31 +0100 Subject: [PATCH 074/157] Package read-me doc --- MoreLinq/MoreLinq.csproj | 2 ++ 1 file changed, 2 insertions(+) diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index a34d230da..ec74962c7 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -133,6 +133,7 @@ https://morelinq.github.io/ COPYING.txt ..\dist + README.md true true true @@ -155,6 +156,7 @@ + TextTemplatingFileGenerator From d2df6854fa735ee709631bea857788fccb32ab48 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 27 Feb 2023 06:12:31 +0100 Subject: [PATCH 075/157] Implement "Fold" entirely in its own terms --- MoreLinq/AssertCount.cs | 22 +++++++--------------- MoreLinq/Extensions.g.cs | 3 ++- MoreLinq/Fold.cs | 19 ++++++++++++------- 3 files changed, 21 insertions(+), 23 deletions(-) diff --git a/MoreLinq/AssertCount.cs b/MoreLinq/AssertCount.cs index 0273bf060..debe5f3ae 100644 --- a/MoreLinq/AssertCount.cs +++ b/MoreLinq/AssertCount.cs @@ -22,8 +22,6 @@ namespace MoreLinq static partial class MoreEnumerable { -#if MORELINQ - static readonly Func DefaultErrorSelector = OnAssertCountFailure; /// @@ -42,7 +40,7 @@ static partial class MoreEnumerable /// public static IEnumerable AssertCount(this IEnumerable source, int count) => - AssertCountImpl(source, count, DefaultErrorSelector); + AssertCount(source, count, DefaultErrorSelector); /// /// Asserts that a source sequence contains a given count of elements. @@ -68,18 +66,6 @@ public static IEnumerable AssertCount(this IEnumerable public static IEnumerable AssertCount(this IEnumerable source, - int count, Func errorSelector) => - AssertCountImpl(source, count, errorSelector); - - static Exception OnAssertCountFailure(int cmp, int count) => - new SequenceException(FormatSequenceLengthErrorMessage(cmp, count)); - - internal static string FormatSequenceLengthErrorMessage(int cmp, int count) => - $"Sequence contains too {(cmp < 0 ? "few" : "many")} elements when exactly {count:N0} {(count == 1 ? "was" : "were")} expected."; - -#endif - - static IEnumerable AssertCountImpl(IEnumerable source, int count, Func errorSelector) { if (source == null) throw new ArgumentNullException(nameof(source)); @@ -106,5 +92,11 @@ static IEnumerable AssertCountImpl(IEnumerable source throw errorSelector(-1, count); } } + + static Exception OnAssertCountFailure(int cmp, int count) => + new SequenceException(FormatSequenceLengthErrorMessage(cmp, count)); + + internal static string FormatSequenceLengthErrorMessage(int cmp, int count) => + $"Sequence contains too {(cmp < 0 ? "few" : "many")} elements when exactly {count:N0} {(count == 1 ? "was" : "were")} expected."; } } diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index 4ec625245..a19f82c10 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -540,7 +540,8 @@ public static partial class AssertCountExtension /// public static IEnumerable AssertCount(this IEnumerable source, - int count, Func errorSelector) => MoreEnumerable.AssertCount(source, count, errorSelector); + int count, Func errorSelector) + => MoreEnumerable.AssertCount(source, count, errorSelector); } diff --git a/MoreLinq/Fold.cs b/MoreLinq/Fold.cs index fde8568e5..f7ad9d094 100644 --- a/MoreLinq/Fold.cs +++ b/MoreLinq/Fold.cs @@ -25,15 +25,20 @@ static partial class MoreEnumerable static T[] Fold(this IEnumerable source, int count) { var elements = new T[count]; - foreach (var e in AssertCountImpl(source.Index(), count, OnFolderSourceSizeErrorSelector)) - elements[e.Key] = e.Value; + var i = 0; - return elements; - } + foreach (var item in source) + { + elements[i] = i < count ? item : throw LengthError(1); + i++; + } - static readonly Func OnFolderSourceSizeErrorSelector = OnFolderSourceSizeError; + if (i < count) + throw LengthError(-1); - static Exception OnFolderSourceSizeError(int cmp, int count) => - new InvalidOperationException(FormatSequenceLengthErrorMessage(cmp, count)); + return elements; + + InvalidOperationException LengthError(int cmp) => new(FormatSequenceLengthErrorMessage(cmp, count)); + } } } From 9b929f0c313a4cba110496a2877e5cda830a45f9 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 27 Feb 2023 06:13:02 +0100 Subject: [PATCH 076/157] Remove unused imports in "ToDelimitedString" --- MoreLinq/ToDelimitedString.g.cs | 2 -- MoreLinq/ToDelimitedString.g.tt | 2 -- 2 files changed, 4 deletions(-) diff --git a/MoreLinq/ToDelimitedString.g.cs b/MoreLinq/ToDelimitedString.g.cs index 17ba8f8e0..b00b88307 100644 --- a/MoreLinq/ToDelimitedString.g.cs +++ b/MoreLinq/ToDelimitedString.g.cs @@ -29,8 +29,6 @@ namespace MoreLinq { using System; using System.Collections.Generic; - using System.Globalization; - using System.Text; partial class MoreEnumerable { diff --git a/MoreLinq/ToDelimitedString.g.tt b/MoreLinq/ToDelimitedString.g.tt index ba38008de..018e482d9 100644 --- a/MoreLinq/ToDelimitedString.g.tt +++ b/MoreLinq/ToDelimitedString.g.tt @@ -38,8 +38,6 @@ namespace MoreLinq { using System; using System.Collections.Generic; - using System.Globalization; - using System.Text; partial class MoreEnumerable {<# From acad56ca6266e79b5cf62dc7b12b6c4c012e72a8 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 27 Feb 2023 08:28:26 +0100 Subject: [PATCH 077/157] Use compiler-generated delegate cache in "AssertCount" --- MoreLinq/AssertCount.cs | 7 +------ MoreLinq/Extensions.g.cs | 1 - 2 files changed, 1 insertion(+), 7 deletions(-) diff --git a/MoreLinq/AssertCount.cs b/MoreLinq/AssertCount.cs index debe5f3ae..14a55c1a4 100644 --- a/MoreLinq/AssertCount.cs +++ b/MoreLinq/AssertCount.cs @@ -22,8 +22,6 @@ namespace MoreLinq static partial class MoreEnumerable { - static readonly Func DefaultErrorSelector = OnAssertCountFailure; - /// /// Asserts that a source sequence contains a given count of elements. /// @@ -40,7 +38,7 @@ static partial class MoreEnumerable /// public static IEnumerable AssertCount(this IEnumerable source, int count) => - AssertCount(source, count, DefaultErrorSelector); + AssertCount(source, count, static (cmp, count) => new SequenceException(FormatSequenceLengthErrorMessage(cmp, count))); /// /// Asserts that a source sequence contains a given count of elements. @@ -93,9 +91,6 @@ public static IEnumerable AssertCount(this IEnumerable - new SequenceException(FormatSequenceLengthErrorMessage(cmp, count)); - internal static string FormatSequenceLengthErrorMessage(int cmp, int count) => $"Sequence contains too {(cmp < 0 ? "few" : "many")} elements when exactly {count:N0} {(count == 1 ? "was" : "were")} expected."; } diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index a19f82c10..e543cbe72 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -498,7 +498,6 @@ public static IEnumerable Assert(this IEnumerable sou [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")] public static partial class AssertCountExtension { - /// /// Asserts that a source sequence contains a given count of elements. /// From b68deb6e5dcf62330b8124cfdc9ef32339f2ea1b Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 27 Feb 2023 21:34:27 +0100 Subject: [PATCH 078/157] Validate package --- .config/dotnet-tools.json | 6 ++ MoreLinq/CompatibilitySuppressions.xml | 130 +++++++++++++++++++++++++ MoreLinq/MoreLinq.csproj | 2 + appveyor.yml | 7 ++ 4 files changed, 145 insertions(+) create mode 100644 MoreLinq/CompatibilitySuppressions.xml diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json index 6cf346f67..516b7dafe 100644 --- a/.config/dotnet-tools.json +++ b/.config/dotnet-tools.json @@ -13,6 +13,12 @@ "commands": [ "reportgenerator" ] + }, + "meziantou.framework.nugetpackagevalidation.tool": { + "version": "1.0.9", + "commands": [ + "meziantou.validate-nuget-package" + ] } } } diff --git a/MoreLinq/CompatibilitySuppressions.xml b/MoreLinq/CompatibilitySuppressions.xml new file mode 100644 index 000000000..75886d3d6 --- /dev/null +++ b/MoreLinq/CompatibilitySuppressions.xml @@ -0,0 +1,130 @@ + + + + + CP0001 + T:MoreLinq.Experimental.AwaitQueryOptions + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0001 + T:MoreLinq.Experimental.IAwaitQuery`1 + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0001 + T:MoreLinq.Extensions.ToDataTableExtension + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0}) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0}) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered``1(MoreLinq.Experimental.IAwaitQuery{``0}) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.Experimental.ExperimentalEnumerable.Await``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}}) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.Experimental.ExperimentalEnumerable.Await``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.Task{``1}}) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.Task{``1}},System.Func{``0,System.Threading.Tasks.Task{``1},``2}) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Boolean) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.Experimental.ExperimentalEnumerable.Scheduler``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Threading.Tasks.TaskScheduler) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0}) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.MoreEnumerable.ToDataTable``1(System.Collections.Generic.IEnumerable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[]) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.MoreEnumerable.ToDataTable``1(System.Collections.Generic.IEnumerable{``0}) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.MoreEnumerable.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1,System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[]) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.MoreEnumerable.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.SequenceException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) + lib/net451/MoreLinq.dll + lib/netstandard1.0/MoreLinq.dll + true + + diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index ec74962c7..a3e52f179 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -134,6 +134,8 @@ COPYING.txt ..\dist README.md + true + 3.3.1 true true true diff --git a/appveyor.yml b/appveyor.yml index a59f94da0..e213363c0 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -83,6 +83,13 @@ after_build: if ($LASTEXITCODE -ne 0) { throw "New code was generated during build that's not been committed." } +- ps: | + dir dist\*.nupkg | % { + dotnet meziantou.validate-nuget-package --excluded-rules IconMustBeSet,Symbols $_ + if ($LASTEXITCODE) { + throw "Package validation failed: $_" + } + } test_script: - cmd: test.cmd - sh: ./test.sh From b99a6a8cc504caf2d48372fe54a2f8116c59cd0c Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 28 Feb 2023 05:31:40 +0100 Subject: [PATCH 079/157] Produce deterministic CI builds This is a squashed merge or PR #975 that closes #973. --- MoreLinq/MoreLinq.csproj | 4 ++++ appveyor.yml | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index a3e52f179..c48c91587 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -148,6 +148,10 @@ + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + runtime; build; native; contentfiles; analyzers all diff --git a/appveyor.yml b/appveyor.yml index e213363c0..24f73d208 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -85,7 +85,7 @@ after_build: } - ps: | dir dist\*.nupkg | % { - dotnet meziantou.validate-nuget-package --excluded-rules IconMustBeSet,Symbols $_ + dotnet meziantou.validate-nuget-package --excluded-rules IconMustBeSet $_ if ($LASTEXITCODE) { throw "Package validation failed: $_" } From 06102d7706cdcb67a8520ab0979b1202703dd8fa Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Wed, 8 Mar 2023 22:52:25 +0100 Subject: [PATCH 080/157] Enable nullable context for extensions generated via T4 Affects: - ToDelimitedString - Aggregate - Fold - Cartesian --- MoreLinq/Aggregate.g.cs | 10 ++++++++++ MoreLinq/Aggregate.g.tt | 10 ++++++++++ MoreLinq/Cartesian.g.cs | 10 ++++++++++ MoreLinq/Cartesian.g.tt | 10 ++++++++++ MoreLinq/Fold.g.cs | 10 ++++++++++ MoreLinq/Fold.g.tt | 10 ++++++++++ MoreLinq/ToDelimitedString.g.cs | 10 ++++++++++ MoreLinq/ToDelimitedString.g.tt | 10 ++++++++++ 8 files changed, 80 insertions(+) diff --git a/MoreLinq/Aggregate.g.cs b/MoreLinq/Aggregate.g.cs index 0bfc49776..ea53d8663 100644 --- a/MoreLinq/Aggregate.g.cs +++ b/MoreLinq/Aggregate.g.cs @@ -15,6 +15,16 @@ // limitations under the License. #endregion +#nullable enable // required for auto-generated sources (see below why) + +// > Older code generation strategies may not be nullable aware. Setting the +// > project-level nullable context to "enable" could result in many +// > warnings that a user is unable to fix. To support this scenario any syntax +// > tree that is determined to be generated will have its nullable state +// > implicitly set to "disable", regardless of the overall project state. +// +// Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code + namespace MoreLinq { using System; diff --git a/MoreLinq/Aggregate.g.tt b/MoreLinq/Aggregate.g.tt index e9d41b3c5..9b3a47f24 100644 --- a/MoreLinq/Aggregate.g.tt +++ b/MoreLinq/Aggregate.g.tt @@ -19,6 +19,16 @@ // See the License for the specific language governing permissions and // limitations under the License. #endregion + +#nullable enable // required for auto-generated sources (see below why) + +// > Older code generation strategies may not be nullable aware. Setting the +// > project-level nullable context to "enable" could result in many +// > warnings that a user is unable to fix. To support this scenario any syntax +// > tree that is determined to be generated will have its nullable state +// > implicitly set to "disable", regardless of the overall project state. +// +// Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code <# var overloads = from args in new[] diff --git a/MoreLinq/Cartesian.g.cs b/MoreLinq/Cartesian.g.cs index cc8658318..64694c065 100644 --- a/MoreLinq/Cartesian.g.cs +++ b/MoreLinq/Cartesian.g.cs @@ -15,6 +15,16 @@ // limitations under the License. #endregion +#nullable enable // required for auto-generated sources (see below why) + +// > Older code generation strategies may not be nullable aware. Setting the +// > project-level nullable context to "enable" could result in many +// > warnings that a user is unable to fix. To support this scenario any syntax +// > tree that is determined to be generated will have its nullable state +// > implicitly set to "disable", regardless of the overall project state. +// +// Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code + namespace MoreLinq { using System; diff --git a/MoreLinq/Cartesian.g.tt b/MoreLinq/Cartesian.g.tt index 8df601e46..4bc112cea 100644 --- a/MoreLinq/Cartesian.g.tt +++ b/MoreLinq/Cartesian.g.tt @@ -20,6 +20,16 @@ // limitations under the License. #endregion +#nullable enable // required for auto-generated sources (see below why) + +// > Older code generation strategies may not be nullable aware. Setting the +// > project-level nullable context to "enable" could result in many +// > warnings that a user is unable to fix. To support this scenario any syntax +// > tree that is determined to be generated will have its nullable state +// > implicitly set to "disable", regardless of the overall project state. +// +// Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code + namespace MoreLinq { using System; diff --git a/MoreLinq/Fold.g.cs b/MoreLinq/Fold.g.cs index e7d64b884..b8f3f8dae 100644 --- a/MoreLinq/Fold.g.cs +++ b/MoreLinq/Fold.g.cs @@ -15,6 +15,16 @@ // limitations under the License. #endregion +#nullable enable // required for auto-generated sources (see below why) + +// > Older code generation strategies may not be nullable aware. Setting the +// > project-level nullable context to "enable" could result in many +// > warnings that a user is unable to fix. To support this scenario any syntax +// > tree that is determined to be generated will have its nullable state +// > implicitly set to "disable", regardless of the overall project state. +// +// Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code + namespace MoreLinq { using System; diff --git a/MoreLinq/Fold.g.tt b/MoreLinq/Fold.g.tt index d5ce0fc74..053b9e9d3 100644 --- a/MoreLinq/Fold.g.tt +++ b/MoreLinq/Fold.g.tt @@ -20,6 +20,16 @@ // limitations under the License. #endregion +#nullable enable // required for auto-generated sources (see below why) + +// > Older code generation strategies may not be nullable aware. Setting the +// > project-level nullable context to "enable" could result in many +// > warnings that a user is unable to fix. To support this scenario any syntax +// > tree that is determined to be generated will have its nullable state +// > implicitly set to "disable", regardless of the overall project state. +// +// Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code + namespace MoreLinq { using System; diff --git a/MoreLinq/ToDelimitedString.g.cs b/MoreLinq/ToDelimitedString.g.cs index b00b88307..b836faf38 100644 --- a/MoreLinq/ToDelimitedString.g.cs +++ b/MoreLinq/ToDelimitedString.g.cs @@ -15,6 +15,16 @@ // limitations under the License. #endregion +#nullable enable // required for auto-generated sources (see below why) + +// > Older code generation strategies may not be nullable aware. Setting the +// > project-level nullable context to "enable" could result in many +// > warnings that a user is unable to fix. To support this scenario any syntax +// > tree that is determined to be generated will have its nullable state +// > implicitly set to "disable", regardless of the overall project state. +// +// Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code + #if !MORELINQ // // For projects that may include/embed this source file directly, suppress the diff --git a/MoreLinq/ToDelimitedString.g.tt b/MoreLinq/ToDelimitedString.g.tt index 018e482d9..b444f4a89 100644 --- a/MoreLinq/ToDelimitedString.g.tt +++ b/MoreLinq/ToDelimitedString.g.tt @@ -24,6 +24,16 @@ // limitations under the License. #endregion +#nullable enable // required for auto-generated sources (see below why) + +// > Older code generation strategies may not be nullable aware. Setting the +// > project-level nullable context to "enable" could result in many +// > warnings that a user is unable to fix. To support this scenario any syntax +// > tree that is determined to be generated will have its nullable state +// > implicitly set to "disable", regardless of the overall project state. +// +// Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code + #if !MORELINQ // // For projects that may include/embed this source file directly, suppress the From e1c767f1142477c784b25bd0b221390f098ee7f6 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Wed, 8 Mar 2023 23:33:04 +0100 Subject: [PATCH 081/157] Fix "Permutations" for when source length > 12 This is a squashed merge of PR #979 that fixes #978. --- MoreLinq/Extensions.g.cs | 3 +++ MoreLinq/NestedLoops.cs | 10 ++++------ MoreLinq/Permutations.cs | 5 ++++- 3 files changed, 11 insertions(+), 7 deletions(-) diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index e543cbe72..2eccc5e1a 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -4511,6 +4511,9 @@ public static partial class PermutationsExtension /// The original sequence to permute. /// /// A sequence of lists representing permutations of the original sequence. + /// + /// Too many permutations (limited by ); thrown during iteration + /// of the resulting sequence. /// /// /// A permutation is a unique re-ordering of the elements of the sequence. diff --git a/MoreLinq/NestedLoops.cs b/MoreLinq/NestedLoops.cs index cb8d74d7a..587b368e0 100644 --- a/MoreLinq/NestedLoops.cs +++ b/MoreLinq/NestedLoops.cs @@ -34,19 +34,17 @@ public static partial class MoreEnumerable /// A sequence of loop repetition counts /// A sequence of Action representing the expansion of a set of nested loops - static IEnumerable NestedLoops(this Action action, IEnumerable loopCounts) + static IEnumerable NestedLoops(this Action action, IEnumerable loopCounts) { if (action == null) throw new ArgumentNullException(nameof(action)); if (loopCounts == null) throw new ArgumentNullException(nameof(loopCounts)); return _(); IEnumerable _() { - var count = loopCounts.Assert(n => n >= 0, - _ => new InvalidOperationException("Invalid loop count (must be greater than or equal to zero).")) - .DefaultIfEmpty() - .Aggregate((acc, x) => acc * x); + var count = loopCounts.DefaultIfEmpty() + .Aggregate((acc, x) => checked(acc * x)); - for (var i = 0; i < count; i++) + for (var i = 0UL; i < count; i++) yield return action; } } diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs index 76204ec26..52e354c60 100644 --- a/MoreLinq/Permutations.cs +++ b/MoreLinq/Permutations.cs @@ -83,7 +83,7 @@ public PermutationEnumerator(IEnumerable valueSet) // The nested loop construction below takes into account the fact that: // 1) for empty sets and sets of cardinality 1, there exists only a single permutation. // 2) for sets larger than 1 element, the number of nested loops needed is: set.Count-1 - _generator = NestedLoops(NextPermutation, Enumerable.Range(2, Math.Max(0, _valueSet.Count - 1))); + _generator = NestedLoops(NextPermutation, Generate(2UL, n => n + 1).Take(Math.Max(0, _valueSet.Count - 1))); Reset(); } @@ -184,6 +184,9 @@ IList PermuteValueSet() /// The original sequence to permute. /// /// A sequence of lists representing permutations of the original sequence. + /// + /// Too many permutations (limited by ); thrown during iteration + /// of the resulting sequence. /// /// /// A permutation is a unique re-ordering of the elements of the sequence. From 899027a6c752c5fad9a931a2d6bf7c10627d4cc6 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 9 Mar 2023 00:05:58 +0100 Subject: [PATCH 082/157] Simplify type check expression in extensions generator --- bld/ExtensionsGenerator/Program.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bld/ExtensionsGenerator/Program.cs b/bld/ExtensionsGenerator/Program.cs index aa68f4fa4..da925e064 100644 --- a/bld/ExtensionsGenerator/Program.cs +++ b/bld/ExtensionsGenerator/Program.cs @@ -258,7 +258,7 @@ from ns in baseImports.Concat(usings) var classes = from md in q select md.Method.Syntax into md - group md by md.Identifier.Value is string id ? id : throw new NullReferenceException() + group md by md.Identifier.Value as string ?? throw new NullReferenceException() into g select new { From e6a2058fe75c1f0de3260cf6cfa2a54c61372e52 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 9 Mar 2023 00:06:49 +0100 Subject: [PATCH 083/157] Prepare for 3.4.1 --- MoreLinq/MoreLinq.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index c48c91587..5e05314d4 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -118,7 +118,7 @@ $([System.Text.RegularExpressions.Regex]::Replace($(Copyright), `\s+`, ` `).Trim()) MoreLINQ en-US - 3.4.0 + 3.4.1 MoreLINQ Developers. net462;netstandard1.0;netstandard2.0;netstandard2.1;net6.0 portable From 498a5e73831e0d4525839a43d1566552f82ce4e7 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 9 Mar 2023 08:21:33 +0100 Subject: [PATCH 084/157] Add public API tracking --- MoreLinq/Extensions.ToDataTable.g.cs | 2 + MoreLinq/Extensions.g.cs | 2 + MoreLinq/Flatten.cs | 2 + MoreLinq/MoreLinq.csproj | 9 + .../PublicAPI/net462/PublicAPI.Shipped.txt | 678 +++++++++++++++++ .../PublicAPI/net462/PublicAPI.Unshipped.txt | 1 + .../PublicAPI/net6.0/PublicAPI.Shipped.txt | 684 ++++++++++++++++++ .../PublicAPI/net6.0/PublicAPI.Unshipped.txt | 1 + .../netstandard1.0/PublicAPI.Shipped.txt | 647 +++++++++++++++++ .../netstandard1.0/PublicAPI.Unshipped.txt | 1 + .../netstandard2.0/PublicAPI.Shipped.txt | 678 +++++++++++++++++ .../netstandard2.0/PublicAPI.Unshipped.txt | 1 + .../netstandard2.1/PublicAPI.Shipped.txt | 684 ++++++++++++++++++ .../netstandard2.1/PublicAPI.Unshipped.txt | 1 + bld/ExtensionsGenerator/Program.cs | 2 + 15 files changed, 3393 insertions(+) create mode 100644 MoreLinq/PublicAPI/net462/PublicAPI.Shipped.txt create mode 100644 MoreLinq/PublicAPI/net462/PublicAPI.Unshipped.txt create mode 100644 MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt create mode 100644 MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt create mode 100644 MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Shipped.txt create mode 100644 MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Unshipped.txt create mode 100644 MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt create mode 100644 MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt create mode 100644 MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt create mode 100644 MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt diff --git a/MoreLinq/Extensions.ToDataTable.g.cs b/MoreLinq/Extensions.ToDataTable.g.cs index b9165678e..20380243d 100644 --- a/MoreLinq/Extensions.ToDataTable.g.cs +++ b/MoreLinq/Extensions.ToDataTable.g.cs @@ -27,6 +27,8 @@ // // Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code +#pragma warning disable RS0041 // Public members should not use oblivious types + namespace MoreLinq.Extensions { using System; diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index 2eccc5e1a..b25c873fb 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -27,6 +27,8 @@ // // Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code +#pragma warning disable RS0041 // Public members should not use oblivious types + namespace MoreLinq.Extensions { using System; diff --git a/MoreLinq/Flatten.cs b/MoreLinq/Flatten.cs index 09e107d01..564da9731 100644 --- a/MoreLinq/Flatten.cs +++ b/MoreLinq/Flatten.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#pragma warning disable RS0041 // Public members should not use oblivious types + namespace MoreLinq { using System; diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 5e05314d4..d2d6b1c9d 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -152,6 +152,10 @@ runtime; build; native; contentfiles; analyzers; buildtransitive all + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + runtime; build; native; contentfiles; analyzers all @@ -254,6 +258,11 @@ + + + + + diff --git a/MoreLinq/PublicAPI/net462/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net462/PublicAPI.Shipped.txt new file mode 100644 index 000000000..1f9122f06 --- /dev/null +++ b/MoreLinq/PublicAPI/net462/PublicAPI.Shipped.txt @@ -0,0 +1,678 @@ +#nullable enable +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 +MoreLinq.Experimental.IAwaitQuery.Options.get -> MoreLinq.Experimental.AwaitQueryOptions! +MoreLinq.Experimental.IAwaitQuery.WithOptions(MoreLinq.Experimental.AwaitQueryOptions! options) -> MoreLinq.Experimental.IAwaitQuery! +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.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.MinByExtension +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 +MoreLinq.IExtremaEnumerable.Take(int count) -> System.Collections.Generic.IEnumerable! +MoreLinq.IExtremaEnumerable.TakeLast(int count) -> System.Collections.Generic.IEnumerable! +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) -> void +MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void +MoreLinq.SequenceException.SequenceException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential(this MoreLinq.Experimental.IAwaitQuery! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable!>! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator, System.Func!, TResult>! resultSelector) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency(this MoreLinq.Experimental.IAwaitQuery! source, int value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Memoize(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder(this MoreLinq.Experimental.IAwaitQuery! source, bool value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Scheduler(this MoreLinq.Experimental.IAwaitQuery! source, System.Threading.Tasks.TaskScheduler! value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many) -> (TCardinality Cardinality, T? Value) +static MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Extensions.AcquireExtension.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SkipUntilExtension.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SliceExtension.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeUntilExtension.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowRightExtension.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Unfold(TState state, System.Func! generator, System.Func! predicate, System.Func! stateSelector, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/net462/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net462/PublicAPI.Unshipped.txt new file mode 100644 index 000000000..7dc5c5811 --- /dev/null +++ b/MoreLinq/PublicAPI/net462/PublicAPI.Unshipped.txt @@ -0,0 +1 @@ +#nullable enable diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt new file mode 100644 index 000000000..91fd806e7 --- /dev/null +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt @@ -0,0 +1,684 @@ +#nullable enable +MoreLinq.Experimental.Async.ExperimentalEnumerable +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 +MoreLinq.Experimental.IAwaitQuery.Options.get -> MoreLinq.Experimental.AwaitQueryOptions! +MoreLinq.Experimental.IAwaitQuery.WithOptions(MoreLinq.Experimental.AwaitQueryOptions! options) -> MoreLinq.Experimental.IAwaitQuery! +MoreLinq.Experimental.ICurrentBuffer +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.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.MinByExtension +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 +MoreLinq.IExtremaEnumerable.Take(int count) -> System.Collections.Generic.IEnumerable! +MoreLinq.IExtremaEnumerable.TakeLast(int count) -> System.Collections.Generic.IEnumerable! +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) -> void +MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void +MoreLinq.SequenceException.SequenceException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void +static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.Collections.Generic.IAsyncEnumerable! +static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.Collections.Generic.IAsyncEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential(this MoreLinq.Experimental.IAwaitQuery! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable!>! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator, System.Func!, TResult>! resultSelector) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Buffers.ArrayPool! pool, System.Func!, System.Collections.Generic.IEnumerable!>! bucketProjectionSelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Buffers.ArrayPool! pool, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency(this MoreLinq.Experimental.IAwaitQuery! source, int value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Memoize(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder(this MoreLinq.Experimental.IAwaitQuery! source, bool value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Scheduler(this MoreLinq.Experimental.IAwaitQuery! source, System.Threading.Tasks.TaskScheduler! value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many) -> (TCardinality Cardinality, T? Value) +static MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Extensions.AcquireExtension.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SkipUntilExtension.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SliceExtension.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeUntilExtension.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowRightExtension.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Unfold(TState state, System.Func! generator, System.Func! predicate, System.Func! stateSelector, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt new file mode 100644 index 000000000..7dc5c5811 --- /dev/null +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt @@ -0,0 +1 @@ +#nullable enable diff --git a/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Shipped.txt new file mode 100644 index 000000000..f6d66a9be --- /dev/null +++ b/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Shipped.txt @@ -0,0 +1,647 @@ +#nullable enable +MoreLinq.Experimental.ExperimentalEnumerable +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.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.MinByExtension +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.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 +MoreLinq.IExtremaEnumerable.Take(int count) -> System.Collections.Generic.IEnumerable! +MoreLinq.IExtremaEnumerable.TakeLast(int count) -> System.Collections.Generic.IEnumerable! +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) -> void +MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Memoize(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many) -> (TCardinality Cardinality, T? Value) +static MoreLinq.Extensions.AcquireExtension.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SkipUntilExtension.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SliceExtension.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeUntilExtension.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowRightExtension.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Unfold(TState state, System.Func! generator, System.Func! predicate, System.Func! stateSelector, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Unshipped.txt new file mode 100644 index 000000000..7dc5c5811 --- /dev/null +++ b/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Unshipped.txt @@ -0,0 +1 @@ +#nullable enable diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt new file mode 100644 index 000000000..1f9122f06 --- /dev/null +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt @@ -0,0 +1,678 @@ +#nullable enable +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 +MoreLinq.Experimental.IAwaitQuery.Options.get -> MoreLinq.Experimental.AwaitQueryOptions! +MoreLinq.Experimental.IAwaitQuery.WithOptions(MoreLinq.Experimental.AwaitQueryOptions! options) -> MoreLinq.Experimental.IAwaitQuery! +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.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.MinByExtension +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 +MoreLinq.IExtremaEnumerable.Take(int count) -> System.Collections.Generic.IEnumerable! +MoreLinq.IExtremaEnumerable.TakeLast(int count) -> System.Collections.Generic.IEnumerable! +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) -> void +MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void +MoreLinq.SequenceException.SequenceException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential(this MoreLinq.Experimental.IAwaitQuery! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable!>! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator, System.Func!, TResult>! resultSelector) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency(this MoreLinq.Experimental.IAwaitQuery! source, int value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Memoize(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder(this MoreLinq.Experimental.IAwaitQuery! source, bool value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Scheduler(this MoreLinq.Experimental.IAwaitQuery! source, System.Threading.Tasks.TaskScheduler! value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many) -> (TCardinality Cardinality, T? Value) +static MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Extensions.AcquireExtension.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SkipUntilExtension.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SliceExtension.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeUntilExtension.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowRightExtension.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Unfold(TState state, System.Func! generator, System.Func! predicate, System.Func! stateSelector, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt new file mode 100644 index 000000000..7dc5c5811 --- /dev/null +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt @@ -0,0 +1 @@ +#nullable enable diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt new file mode 100644 index 000000000..91fd806e7 --- /dev/null +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt @@ -0,0 +1,684 @@ +#nullable enable +MoreLinq.Experimental.Async.ExperimentalEnumerable +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 +MoreLinq.Experimental.IAwaitQuery.Options.get -> MoreLinq.Experimental.AwaitQueryOptions! +MoreLinq.Experimental.IAwaitQuery.WithOptions(MoreLinq.Experimental.AwaitQueryOptions! options) -> MoreLinq.Experimental.IAwaitQuery! +MoreLinq.Experimental.ICurrentBuffer +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.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.MinByExtension +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 +MoreLinq.IExtremaEnumerable.Take(int count) -> System.Collections.Generic.IEnumerable! +MoreLinq.IExtremaEnumerable.TakeLast(int count) -> System.Collections.Generic.IEnumerable! +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) -> void +MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void +MoreLinq.SequenceException.SequenceException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void +static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.Collections.Generic.IAsyncEnumerable! +static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.Collections.Generic.IAsyncEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential(this MoreLinq.Experimental.IAwaitQuery! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable!>! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator, System.Func!, TResult>! resultSelector) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Buffers.ArrayPool! pool, System.Func!, System.Collections.Generic.IEnumerable!>! bucketProjectionSelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Buffers.ArrayPool! pool, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency(this MoreLinq.Experimental.IAwaitQuery! source, int value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Memoize(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder(this MoreLinq.Experimental.IAwaitQuery! source, bool value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Scheduler(this MoreLinq.Experimental.IAwaitQuery! source, System.Threading.Tasks.TaskScheduler! value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many) -> (TCardinality Cardinality, T? Value) +static MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Extensions.AcquireExtension.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SkipUntilExtension.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SliceExtension.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeUntilExtension.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowRightExtension.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Unfold(TState state, System.Func! generator, System.Func! predicate, System.Func! stateSelector, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt new file mode 100644 index 000000000..7dc5c5811 --- /dev/null +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt @@ -0,0 +1 @@ +#nullable enable diff --git a/bld/ExtensionsGenerator/Program.cs b/bld/ExtensionsGenerator/Program.cs index da925e064..f058842af 100644 --- a/bld/ExtensionsGenerator/Program.cs +++ b/bld/ExtensionsGenerator/Program.cs @@ -329,6 +329,8 @@ public static partial class {m.Name}Extension // // Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code +#pragma warning disable RS0041 // Public members should not use oblivious types + namespace MoreLinq.Extensions {{ {string.Join("\n", imports)} From 93bc6dca9670feb60282f06eda19b18ebc21550a Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 9 Mar 2023 18:30:39 +0100 Subject: [PATCH 085/157] Use raw strings for quoted code in extensions generator --- bld/ExtensionsGenerator/Program.cs | 105 +++++++++++++++-------------- 1 file changed, 55 insertions(+), 50 deletions(-) diff --git a/bld/ExtensionsGenerator/Program.cs b/bld/ExtensionsGenerator/Program.cs index f058842af..d275c3272 100644 --- a/bld/ExtensionsGenerator/Program.cs +++ b/bld/ExtensionsGenerator/Program.cs @@ -290,57 +290,62 @@ select Argument(IdentifierName(p.Identifier)), .WithSemicolonToken(ParseToken(";").WithTrailingTrivia(LineFeed)) } into m - select (!noClassLead ? $@" - /// {m.Name} extension. - - [GeneratedCode(""{thisAssemblyName.Name}"", ""{thisAssemblyName.Version}"")]" : null) + $@" - public static partial class {m.Name}Extension - {{ -{string.Join(null, from mo in m.Overloads select mo.ToFullString())} - }}"; - - var template = $@" -#region License and Terms -// MoreLINQ - Extensions to LINQ to Objects -// -// Licensed under the Apache License, Version 2.0 (the ""License""); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an ""AS IS"" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -#endregion - -// This code was generated by a tool. Any changes made manually will be lost -// the next time this code is regenerated. - -#nullable enable // required for auto-generated sources (see below why) - -// > Older code generation strategies may not be nullable aware. Setting the -// > project-level nullable context to ""enable"" could result in many -// > warnings that a user is unable to fix. To support this scenario any syntax -// > tree that is determined to be generated will have its nullable state -// > implicitly set to ""disable"", regardless of the overall project state. -// -// Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code - -#pragma warning disable RS0041 // Public members should not use oblivious types - -namespace MoreLinq.Extensions -{{ -{string.Join("\n", imports)} -{string.Join("\n", classes)} -}} - "; + let classLead = !noClassLead + ? $$""" + + /// {{m.Name}} extension. + + [GeneratedCode("{{thisAssemblyName.Name}}", "{{thisAssemblyName.Version}}")] + """ + : null + select $$""" + {{classLead}} + public static partial class {{m.Name}}Extension + { + {{string.Join(null, from mo in m.Overloads select mo.ToFullString())}} + } + """; + + var template = $$""" + #region License and Terms + // MoreLINQ - Extensions to LINQ to Objects + // + // Licensed under the Apache License, Version 2.0 (the "License"); + // you may not use this file except in compliance with the License. + // You may obtain a copy of the License at + // + // http://www.apache.org/licenses/LICENSE-2.0 + // + // Unless required by applicable law or agreed to in writing, software + // distributed under the License is distributed on an "AS IS" BASIS, + // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + // See the License for the specific language governing permissions and + // limitations under the License. + #endregion + + // This code was generated by a tool. Any changes made manually will be lost + // the next time this code is regenerated. + + #nullable enable // required for auto-generated sources (see below why) + + // > Older code generation strategies may not be nullable aware. Setting the + // > project-level nullable context to "enable" could result in many + // > warnings that a user is unable to fix. To support this scenario any syntax + // > tree that is determined to be generated will have its nullable state + // > implicitly set to "disable", regardless of the overall project state. + // + // Source: https://github.com/dotnet/roslyn/blob/70e158ba6c2c99bd3c3fc0754af0dbf82a6d353d/docs/features/nullable-reference-types.md#generated-code + + #pragma warning disable RS0041 // Public members should not use oblivious types + + namespace MoreLinq.Extensions + { + {{string.Join("\n", imports)}} + {{string.Join("\n", classes)}} + } + """; - Console.WriteLine(template.Trim() - // normalize line endings - .Replace("\r", string.Empty, StringComparison.Ordinal) + Console.WriteLine(template.Replace("\r", string.Empty, StringComparison.Ordinal) .Replace("\n", Environment.NewLine, StringComparison.Ordinal)); } From c44b7eb67cfd1c6be04a045de5c3374278549945 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 12 Mar 2023 14:24:38 +0100 Subject: [PATCH 086/157] Fix error handling in CMD scripts --- build.cmd | 9 ++++----- builddocs.cmd | 2 +- msbuild.cmd | 4 ++-- pack.cmd | 7 +++---- test.cmd | 11 +++++------ 5 files changed, 15 insertions(+), 18 deletions(-) diff --git a/build.cmd b/build.cmd index ae3dbc0db..632a0534c 100644 --- a/build.cmd +++ b/build.cmd @@ -1,8 +1,7 @@ @echo off pushd "%~dp0" call :main %* -popd -goto :EOF +popd & exit /b %ERRORLEVEL% :main setlocal @@ -15,11 +14,11 @@ dotnet restore && dotnet tool restore ^ && call :codegen MoreLinq\Extensions.ToDataTable.g.cs -i "[/\\]ToDataTable\.cs$" -u System.Data -u System.Linq.Expressions MoreLinq ^ && call MoreLinq\tt ^ && for %%i in (debug release) do dotnet build -c %%i --no-restore %* || exit /b 1 -goto :EOF +exit /b %ERRORLEVEL% :docs call :build && call msbuild.cmd MoreLinq.shfbproj %1 %2 %3 %4 %5 %6 %7 %8 %9 -goto :EOF +exit /b %ERRORLEVEL% :nodotnet echo>&2 dotnet executable not found in PATH @@ -31,4 +30,4 @@ echo | set /p=Generating extensions wrappers (%1)... dotnet run --project bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj -c Release -- %2 %3 %4 %5 %6 %7 %8 %9 > "%temp%\%~nx1" ^ && move "%temp%\%~nx1" "%~dp1" > nul ^ && echo Done. -goto :EOF +exit /b %ERRORLEVEL% diff --git a/builddocs.cmd b/builddocs.cmd index a46f09c1e..c26f6c472 100644 --- a/builddocs.cmd +++ b/builddocs.cmd @@ -1 +1 @@ -@"%~dp0build" docs +@call "%~dp0build" docs diff --git a/msbuild.cmd b/msbuild.cmd index 406eea283..558d91a99 100644 --- a/msbuild.cmd +++ b/msbuild.cmd @@ -18,7 +18,7 @@ if not defined MSBUILD_VERSION_MAJOR goto :nomsbuild if %MSBUILD_VERSION_MAJOR% lss 17 goto :nomsbuild :build "%MSBUILD%" %* -goto :EOF +exit /b %ERRORLEVEL% :nomsbuild echo>&2 Microsoft Build Engine 17.0 or a later version is required to build @@ -27,4 +27,4 @@ echo>&2 https://docs.microsoft.com/en-us/visualstudio/install/use-command-line-p echo>&2 At the very least, you will want to install the MSBuilt Tool workload echo>&2 that has the identifier "Microsoft.VisualStudio.Workload.MSBuildTools": echo>&2 https://docs.microsoft.com/en-us/visualstudio/install/workload-component-id-vs-build-tools#msbuild-tools -exit /b s +exit /b 1 diff --git a/pack.cmd b/pack.cmd index 6aacf62fe..ccf3c7fa5 100644 --- a/pack.cmd +++ b/pack.cmd @@ -1,15 +1,14 @@ @echo off pushd "%~dp0" call :main %* -popd -goto :EOF +popd & exit /b %ERRORLEVEL% :main setlocal if not exist dist md dist -if not %errorlevel%==0 exit /b %errorlevel% +if not %ERRORLEVEL%==0 exit /b %ERRORLEVEL% set VERSION_SUFFIX= if not "%~1"=="" set VERSION_SUFFIX=/p:VersionSuffix=%1 call build ^ && dotnet pack --no-build -c Release %VERSION_SUFFIX% -goto :EOF +exit /b %ERRORLEVEL% diff --git a/test.cmd b/test.cmd index eec32dd03..c4f74dc2d 100644 --- a/test.cmd +++ b/test.cmd @@ -1,8 +1,7 @@ @echo off pushd "%~dp0" call :main %* -popd -goto :EOF +popd & exit /b %ERRORLEVEL% :main setlocal @@ -15,14 +14,14 @@ call build ^ && call :test net462 Debug ^ && call :test net462 Release ^ && call :report-cover -goto :EOF +exit /b %ERRORLEVEL% :clean setlocal cd MoreLinq.Test if exist TestResults rd /s /q TestResults || exit /b 1 if exist TestResult.xml del TestResult.xml || exit /b 1 -goto :EOF +exit /b %ERRORLEVEL% :test setlocal @@ -41,7 +40,7 @@ if not defined TEST_RESULTS_DIR ( exit /b 1 ) copy "%TEST_RESULTS_DIR%\coverage.opencover.xml" coverage-%1-%2.opencover.xml > nul -goto :EOF +exit /b %ERRORLEVEL% :report-cover setlocal @@ -50,4 +49,4 @@ dotnet reportgenerator -reports:coverage-*.opencover.xml ^ -reporttypes:Html;TextSummary ^ -targetdir:reports ^ && type reports\Summary.txt -goto :EOF +exit /b %ERRORLEVEL% From d2bcbf68d73dcca64b62d66e02f33cb662a3ff3d Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 12 Mar 2023 14:16:51 +0100 Subject: [PATCH 087/157] Update "dotnet-install" scripts Source: https://learn.microsoft.com/en-us/dotnet/core/tools/dotnet-install-script --- tools/dotnet-install.ps1 | 1227 +++++++++++++++++++++++++++----------- tools/dotnet-install.sh | 1058 +++++++++++++++++++++++++------- 2 files changed, 1718 insertions(+), 567 deletions(-) diff --git a/tools/dotnet-install.ps1 b/tools/dotnet-install.ps1 index 99798362c..3821006a3 100644 --- a/tools/dotnet-install.ps1 +++ b/tools/dotnet-install.ps1 @@ -12,21 +12,32 @@ .PARAMETER Channel Default: LTS Download from the Channel specified. Possible values: - - Current - most current release - - LTS - most current supported release + - STS - the most recent Standard Term Support release + - LTS - the most recent Long Term Support release - 2-part version in a format A.B - represents a specific release examples: 2.0, 1.0 - - Branch name - examples: release/2.0.0, Master - Note: The version parameter overrides the channel parameter. + - 3-part version in a format A.B.Cxx - represents a specific SDK release + examples: 5.0.1xx, 5.0.2xx + Supported since 5.0 release + Warning: Value "Current" is deprecated for the Channel parameter. Use "STS" instead. + Note: The version parameter overrides the channel parameter when any version other than 'latest' is used. +.PARAMETER Quality + Download the latest build of specified quality in the channel. The possible values are: daily, signed, validated, preview, GA. + Works only in combination with channel. Not applicable for STS and LTS channels and will be ignored if those channels are used. + For SDK use channel in A.B.Cxx format: using quality together with channel in A.B format is not supported. + Supported since 5.0 release. + Note: The version parameter overrides the channel parameter when any version other than 'latest' is used, and therefore overrides the quality. .PARAMETER Version Default: latest Represents a build version on specific channel. Possible values: - - latest - most latest build on specific channel - - coherent - most latest coherent build on specific channel - coherent applies only to SDK downloads + - latest - the latest build on specific channel - 3-part version in a format A.B.C - represents specific version of build examples: 2.0.0-preview2-006120, 1.1.0 +.PARAMETER Internal + Download internal builds. Requires providing credentials via -FeedCredential parameter. +.PARAMETER FeedCredential + Token to access Azure feed. Used as a query string to append to the Azure feed. + This parameter typically is not specified. .PARAMETER InstallDir Default: %LocalAppData%\Microsoft\dotnet Path to where to install dotnet. Note that binaries will be placed directly in a given directory. @@ -56,14 +67,13 @@ Displays diagnostics information. .PARAMETER AzureFeed Default: https://dotnetcli.azureedge.net/dotnet - This parameter typically is not changed by the user. - It allows changing the URL for the Azure feed used by this installer. + For internal use only. + Allows using a different storage to download SDK archives from. + This parameter is only used if $NoCdn is false. .PARAMETER UncachedFeed - This parameter typically is not changed by the user. - It allows changing the URL for the Uncached feed used by this installer. -.PARAMETER FeedCredential - Used as a query string to append to the Azure feed. - It allows changing the URL to use non-public blob storage accounts. + For internal use only. + Allows using a different storage to download SDK archives from. + This parameter is only used if $NoCdn is true. .PARAMETER ProxyAddress If set, the installer will use the proxy when making web requests .PARAMETER ProxyUseDefaultCredentials @@ -79,67 +89,76 @@ .PARAMETER JSonFile Determines the SDK version from a user specified global.json file Note: global.json must have a value for 'SDK:Version' +.PARAMETER DownloadTimeout + Determines timeout duration in seconds for dowloading of the SDK file + Default: 1200 seconds (20 minutes) #> [cmdletbinding()] param( [string]$Channel="LTS", + [string]$Quality, [string]$Version="Latest", + [switch]$Internal, [string]$JSonFile, - [string]$InstallDir="", + [Alias('i')][string]$InstallDir="", [string]$Architecture="", - [ValidateSet("dotnet", "aspnetcore", "windowsdesktop", IgnoreCase = $false)] [string]$Runtime, [Obsolete("This parameter may be removed in a future version of this script. The recommended alternative is '-Runtime dotnet'.")] [switch]$SharedRuntime, [switch]$DryRun, [switch]$NoPath, - [string]$AzureFeed="https://dotnetcli.azureedge.net/dotnet", - [string]$UncachedFeed="https://dotnetcli.blob.core.windows.net/dotnet", + [string]$AzureFeed, + [string]$UncachedFeed, [string]$FeedCredential, [string]$ProxyAddress, [switch]$ProxyUseDefaultCredentials, [string[]]$ProxyBypassList=@(), [switch]$SkipNonVersionedFiles, - [switch]$NoCdn + [switch]$NoCdn, + [int]$DownloadTimeout=1200 ) Set-StrictMode -Version Latest $ErrorActionPreference="Stop" $ProgressPreference="SilentlyContinue" -if ($NoCdn) { - $AzureFeed = $UncachedFeed -} - -$BinFolderRelativePath="" - -if ($SharedRuntime -and (-not $Runtime)) { - $Runtime = "dotnet" -} - -# example path with regex: shared/1.0.0-beta-12345/somepath -$VersionRegEx="/\d+\.\d+[^/]+/" -$OverrideNonVersionedFiles = !$SkipNonVersionedFiles - function Say($str) { - try - { + try { Write-Host "dotnet-install: $str" } - catch - { + catch { # Some platforms cannot utilize Write-Host (Azure Functions, for instance). Fall back to Write-Output Write-Output "dotnet-install: $str" } } +function Say-Warning($str) { + try { + Write-Warning "dotnet-install: $str" + } + catch { + # Some platforms cannot utilize Write-Warning (Azure Functions, for instance). Fall back to Write-Output + Write-Output "dotnet-install: Warning: $str" + } +} + +# Writes a line with error style settings. +# Use this function to show a human-readable comment along with an exception. +function Say-Error($str) { + try { + # Write-Error is quite oververbose for the purpose of the function, let's write one line with error style settings. + $Host.UI.WriteErrorLine("dotnet-install: $str") + } + catch { + Write-Output "dotnet-install: Error: $str" + } +} + function Say-Verbose($str) { - try - { + try { Write-Verbose "dotnet-install: $str" } - catch - { + catch { # Some platforms cannot utilize Write-Verbose (Azure Functions, for instance). Fall back to Write-Output Write-Output "dotnet-install: $str" } @@ -151,20 +170,25 @@ function Say-Invocation($Invocation) { Say-Verbose "$command $args" } -function Invoke-With-Retry([ScriptBlock]$ScriptBlock, [int]$MaxAttempts = 3, [int]$SecondsBetweenAttempts = 1) { +function Invoke-With-Retry([ScriptBlock]$ScriptBlock, [System.Threading.CancellationToken]$cancellationToken = [System.Threading.CancellationToken]::None, [int]$MaxAttempts = 3, [int]$SecondsBetweenAttempts = 1) { $Attempts = 0 + $local:startTime = $(get-date) while ($true) { try { - return $ScriptBlock.Invoke() + return & $ScriptBlock } catch { $Attempts++ - if ($Attempts -lt $MaxAttempts) { + if (($Attempts -lt $MaxAttempts) -and -not $cancellationToken.IsCancellationRequested) { Start-Sleep $SecondsBetweenAttempts } else { - throw + $local:elapsedTime = $(get-date) - $local:startTime + if (($local:elapsedTime.TotalSeconds - $DownloadTimeout) -gt 0 -and -not $cancellationToken.IsCancellationRequested) { + throw New-Object System.TimeoutException("Failed to reach the server: connection timeout: default timeout is $DownloadTimeout second(s)"); + } + throw; } } } @@ -177,20 +201,34 @@ function Get-Machine-Architecture() { # To get the correct architecture, we need to use PROCESSOR_ARCHITEW6432. # PS x64 doesn't define this, so we fall back to PROCESSOR_ARCHITECTURE. # Possible values: amd64, x64, x86, arm64, arm - - if( $ENV:PROCESSOR_ARCHITEW6432 -ne $null ) - { + if( $ENV:PROCESSOR_ARCHITEW6432 -ne $null ) { return $ENV:PROCESSOR_ARCHITEW6432 } + try { + if( ((Get-CimInstance -ClassName CIM_OperatingSystem).OSArchitecture) -like "ARM*") { + if( [Environment]::Is64BitOperatingSystem ) + { + return "arm64" + } + return "arm" + } + } + catch { + # Machine doesn't support Get-CimInstance + } + return $ENV:PROCESSOR_ARCHITECTURE } function Get-CLIArchitecture-From-Architecture([string]$Architecture) { Say-Invocation $MyInvocation - switch ($Architecture.ToLower()) { - { $_ -eq "" } { return Get-CLIArchitecture-From-Architecture $(Get-Machine-Architecture) } + if ($Architecture -eq "") { + $Architecture = Get-Machine-Architecture + } + + switch ($Architecture.ToLowerInvariant()) { { ($_ -eq "amd64") -or ($_ -eq "x64") } { return "x64" } { $_ -eq "x86" } { return "x86" } { $_ -eq "arm" } { return "arm" } @@ -199,13 +237,83 @@ function Get-CLIArchitecture-From-Architecture([string]$Architecture) { } } +function ValidateFeedCredential([string] $FeedCredential) +{ + if ($Internal -and [string]::IsNullOrWhitespace($FeedCredential)) { + $message = "Provide credentials via -FeedCredential parameter." + if ($DryRun) { + Say-Warning "$message" + } else { + throw "$message" + } + } + + #FeedCredential should start with "?", for it to be added to the end of the link. + #adding "?" at the beginning of the FeedCredential if needed. + if ((![string]::IsNullOrWhitespace($FeedCredential)) -and ($FeedCredential[0] -ne '?')) { + $FeedCredential = "?" + $FeedCredential + } + + return $FeedCredential +} +function Get-NormalizedQuality([string]$Quality) { + Say-Invocation $MyInvocation + + if ([string]::IsNullOrEmpty($Quality)) { + return "" + } + + switch ($Quality) { + { @("daily", "signed", "validated", "preview") -contains $_ } { return $Quality.ToLowerInvariant() } + #ga quality is available without specifying quality, so normalizing it to empty + { $_ -eq "ga" } { return "" } + default { throw "'$Quality' is not a supported value for -Quality option. Supported values are: daily, signed, validated, preview, ga. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues." } + } +} + +function Get-NormalizedChannel([string]$Channel) { + Say-Invocation $MyInvocation + + if ([string]::IsNullOrEmpty($Channel)) { + return "" + } + + if ($Channel.Contains("Current")) { + Say-Warning 'Value "Current" is deprecated for -Channel option. Use "STS" instead.' + } + + if ($Channel.StartsWith('release/')) { + Say-Warning 'Using branch name with -Channel option is no longer supported with newer releases. Use -Quality option with a channel in X.Y format instead, such as "-Channel 5.0 -Quality Daily."' + } + + switch ($Channel) { + { $_ -eq "lts" } { return "LTS" } + { $_ -eq "sts" } { return "STS" } + { $_ -eq "current" } { return "STS" } + default { return $Channel.ToLowerInvariant() } + } +} + +function Get-NormalizedProduct([string]$Runtime) { + Say-Invocation $MyInvocation + + switch ($Runtime) { + { $_ -eq "dotnet" } { return "dotnet-runtime" } + { $_ -eq "aspnetcore" } { return "aspnetcore-runtime" } + { $_ -eq "windowsdesktop" } { return "windowsdesktop-runtime" } + { [string]::IsNullOrEmpty($_) } { return "dotnet-sdk" } + default { throw "'$Runtime' is not a supported value for -Runtime option, supported values are: dotnet, aspnetcore, windowsdesktop. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues." } + } +} + + # The version text returned from the feeds is a 1-line or 2-line string: # For the SDK and the dotnet runtime (2 lines): # Line 1: # commit_hash # Line 2: # 4-part version # For the aspnetcore runtime (1 line): # Line 1: # 4-part version -function Get-Version-Info-From-Version-Text([string]$VersionText) { +function Get-Version-From-LatestVersion-File-Content([string]$VersionText) { Say-Invocation $MyInvocation $Data = -split $VersionText @@ -227,10 +335,11 @@ function Load-Assembly([string] $Assembly) { } } -function GetHTTPResponse([Uri] $Uri) +function GetHTTPResponse([Uri] $Uri, [bool]$HeaderOnly, [bool]$DisableRedirect, [bool]$DisableFeedCredential) { - Invoke-With-Retry( - { + $cts = New-Object System.Threading.CancellationTokenSource + + $downloadScript = { $HttpClient = $null @@ -243,7 +352,11 @@ function GetHTTPResponse([Uri] $Uri) # Despite no proxy being explicitly specified, we may still be behind a default proxy $DefaultProxy = [System.Net.WebRequest]::DefaultWebProxy; if($DefaultProxy -and (-not $DefaultProxy.IsBypassed($Uri))) { - $ProxyAddress = $DefaultProxy.GetProxy($Uri).OriginalString + if ($null -ne $DefaultProxy.GetProxy($Uri)) { + $ProxyAddress = $DefaultProxy.GetProxy($Uri).OriginalString + } else { + $ProxyAddress = $null + } $ProxyUseDefaultCredentials = $true } } catch { @@ -254,73 +367,126 @@ function GetHTTPResponse([Uri] $Uri) } } + $HttpClientHandler = New-Object System.Net.Http.HttpClientHandler if($ProxyAddress) { - $HttpClientHandler = New-Object System.Net.Http.HttpClientHandler $HttpClientHandler.Proxy = New-Object System.Net.WebProxy -Property @{ Address=$ProxyAddress; UseDefaultCredentials=$ProxyUseDefaultCredentials; BypassList = $ProxyBypassList; } - $HttpClient = New-Object System.Net.Http.HttpClient -ArgumentList $HttpClientHandler + } + if ($DisableRedirect) + { + $HttpClientHandler.AllowAutoRedirect = $false + } + $HttpClient = New-Object System.Net.Http.HttpClient -ArgumentList $HttpClientHandler + + # Default timeout for HttpClient is 100s. For a 50 MB download this assumes 500 KB/s average, any less will time out + # Defaulting to 20 minutes allows it to work over much slower connections. + $HttpClient.Timeout = New-TimeSpan -Seconds $DownloadTimeout + + if ($HeaderOnly){ + $completionOption = [System.Net.Http.HttpCompletionOption]::ResponseHeadersRead } else { + $completionOption = [System.Net.Http.HttpCompletionOption]::ResponseContentRead + } - $HttpClient = New-Object System.Net.Http.HttpClient + if ($DisableFeedCredential) { + $UriWithCredential = $Uri } - # Default timeout for HttpClient is 100s. For a 50 MB download this assumes 500 KB/s average, any less will time out - # 20 minutes allows it to work over much slower connections. - $HttpClient.Timeout = New-TimeSpan -Minutes 20 - $Response = $HttpClient.GetAsync("${Uri}${FeedCredential}").Result - if (($Response -eq $null) -or (-not ($Response.IsSuccessStatusCode))) { - # The feed credential is potentially sensitive info. Do not log FeedCredential to console output. - $ErrorMsg = "Failed to download $Uri." - if ($Response -ne $null) { - $ErrorMsg += " $Response" + else { + $UriWithCredential = "${Uri}${FeedCredential}" + } + + $Task = $HttpClient.GetAsync("$UriWithCredential", $completionOption).ConfigureAwait("false"); + $Response = $Task.GetAwaiter().GetResult(); + + if (($null -eq $Response) -or ((-not $HeaderOnly) -and (-not ($Response.IsSuccessStatusCode)))) { + # The feed credential is potentially sensitive info. Do not log FeedCredential to console output. + $DownloadException = [System.Exception] "Unable to download $Uri." + + if ($null -ne $Response) { + $DownloadException.Data["StatusCode"] = [int] $Response.StatusCode + $DownloadException.Data["ErrorMessage"] = "Unable to download $Uri. Returned HTTP status code: " + $DownloadException.Data["StatusCode"] + + if (404 -eq [int] $Response.StatusCode) + { + $cts.Cancel() + } } - throw $ErrorMsg + throw $DownloadException + } + + return $Response + } + catch [System.Net.Http.HttpRequestException] { + $DownloadException = [System.Exception] "Unable to download $Uri." + + # Pick up the exception message and inner exceptions' messages if they exist + $CurrentException = $PSItem.Exception + $ErrorMsg = $CurrentException.Message + "`r`n" + while ($CurrentException.InnerException) { + $CurrentException = $CurrentException.InnerException + $ErrorMsg += $CurrentException.Message + "`r`n" + } + + # Check if there is an issue concerning TLS. + if ($ErrorMsg -like "*SSL/TLS*") { + $ErrorMsg += "Ensure that TLS 1.2 or higher is enabled to use this script.`r`n" } - return $Response + $DownloadException.Data["ErrorMessage"] = $ErrorMsg + throw $DownloadException } finally { - if ($HttpClient -ne $null) { + if ($null -ne $HttpClient) { $HttpClient.Dispose() } } - }) + } + + try { + return Invoke-With-Retry $downloadScript $cts.Token + } + finally + { + if ($null -ne $cts) + { + $cts.Dispose() + } + } } -function Get-Latest-Version-Info([string]$AzureFeed, [string]$Channel, [bool]$Coherent) { +function Get-Version-From-LatestVersion-File([string]$AzureFeed, [string]$Channel) { Say-Invocation $MyInvocation $VersionFileUrl = $null if ($Runtime -eq "dotnet") { - $VersionFileUrl = "$UncachedFeed/Runtime/$Channel/latest.version" + $VersionFileUrl = "$AzureFeed/Runtime/$Channel/latest.version" } elseif ($Runtime -eq "aspnetcore") { - $VersionFileUrl = "$UncachedFeed/aspnetcore/Runtime/$Channel/latest.version" + $VersionFileUrl = "$AzureFeed/aspnetcore/Runtime/$Channel/latest.version" } - # Currently, the WindowsDesktop runtime is manufactured with the .Net core runtime elseif ($Runtime -eq "windowsdesktop") { - $VersionFileUrl = "$UncachedFeed/Runtime/$Channel/latest.version" + $VersionFileUrl = "$AzureFeed/WindowsDesktop/$Channel/latest.version" } elseif (-not $Runtime) { - if ($Coherent) { - $VersionFileUrl = "$UncachedFeed/Sdk/$Channel/latest.coherent.version" - } - else { - $VersionFileUrl = "$UncachedFeed/Sdk/$Channel/latest.version" - } + $VersionFileUrl = "$AzureFeed/Sdk/$Channel/latest.version" } else { throw "Invalid value for `$Runtime" } + + Say-Verbose "Constructed latest.version URL: $VersionFileUrl" + try { $Response = GetHTTPResponse -Uri $VersionFileUrl } catch { - throw "Could not resolve version information." + Say-Verbose "Failed to download latest.version file." + throw } $StringContent = $Response.Content.ReadAsStringAsync().Result @@ -331,7 +497,7 @@ function Get-Latest-Version-Info([string]$AzureFeed, [string]$Channel, [bool]$Co default { throw "``$Response.Content.Headers.ContentType`` is an unknown .version file content type." } } - $VersionInfo = Get-Version-Info-From-Version-Text $VersionText + $VersionInfo = Get-Version-From-LatestVersion-File-Content $VersionText return $VersionInfo } @@ -346,7 +512,8 @@ function Parse-Jsonfile-For-Version([string]$JSonFile) { $JSonContent = Get-Content($JSonFile) -Raw | ConvertFrom-Json | Select-Object -expand "sdk" -ErrorAction SilentlyContinue } catch { - throw "Json file unreadable: '$JSonFile'" + Say-Error "Json file unreadable: '$JSonFile'" + throw } if ($JSonContent) { try { @@ -359,7 +526,8 @@ function Parse-Jsonfile-For-Version([string]$JSonFile) { } } catch { - throw "Unable to parse the SDK node in '$JSonFile'" + Say-Error "Unable to parse the SDK node in '$JSonFile'" + throw } } else { @@ -375,16 +543,12 @@ function Get-Specific-Version-From-Version([string]$AzureFeed, [string]$Channel, Say-Invocation $MyInvocation if (-not $JSonFile) { - switch ($Version.ToLower()) { - { $_ -eq "latest" } { - $LatestVersionInfo = Get-Latest-Version-Info -AzureFeed $AzureFeed -Channel $Channel -Coherent $False - return $LatestVersionInfo.Version - } - { $_ -eq "coherent" } { - $LatestVersionInfo = Get-Latest-Version-Info -AzureFeed $AzureFeed -Channel $Channel -Coherent $True - return $LatestVersionInfo.Version - } - default { return $Version } + if ($Version.ToLowerInvariant() -eq "latest") { + $LatestVersionInfo = Get-Version-From-LatestVersion-File -AzureFeed $AzureFeed -Channel $Channel + return $LatestVersionInfo.Version + } + else { + return $Version } } else { @@ -405,7 +569,16 @@ function Get-Download-Link([string]$AzureFeed, [string]$SpecificVersion, [string $PayloadURL = "$AzureFeed/aspnetcore/Runtime/$SpecificVersion/aspnetcore-runtime-$SpecificProductVersion-win-$CLIArchitecture.zip" } elseif ($Runtime -eq "windowsdesktop") { + # The windows desktop runtime is part of the core runtime layout prior to 5.0 $PayloadURL = "$AzureFeed/Runtime/$SpecificVersion/windowsdesktop-runtime-$SpecificProductVersion-win-$CLIArchitecture.zip" + if ($SpecificVersion -match '^(\d+)\.(.*)$') + { + $majorVersion = [int]$Matches[1] + if ($majorVersion -ge 5) + { + $PayloadURL = "$AzureFeed/WindowsDesktop/$SpecificVersion/windowsdesktop-runtime-$SpecificProductVersion-win-$CLIArchitecture.zip" + } + } } elseif (-not $Runtime) { $PayloadURL = "$AzureFeed/Sdk/$SpecificVersion/dotnet-sdk-$SpecificProductVersion-win-$CLIArchitecture.zip" @@ -437,48 +610,115 @@ function Get-LegacyDownload-Link([string]$AzureFeed, [string]$SpecificVersion, [ return $PayloadURL } -function Get-Product-Version([string]$AzureFeed, [string]$SpecificVersion) { +function Get-Product-Version([string]$AzureFeed, [string]$SpecificVersion, [string]$PackageDownloadLink) { Say-Invocation $MyInvocation - if ($Runtime -eq "dotnet") { - $ProductVersionTxtURL = "$AzureFeed/Runtime/$SpecificVersion/productVersion.txt" + # Try to get the version number, using the productVersion.txt file located next to the installer file. + $ProductVersionTxtURLs = (Get-Product-Version-Url $AzureFeed $SpecificVersion $PackageDownloadLink -Flattened $true), + (Get-Product-Version-Url $AzureFeed $SpecificVersion $PackageDownloadLink -Flattened $false) + + Foreach ($ProductVersionTxtURL in $ProductVersionTxtURLs) { + Say-Verbose "Checking for the existence of $ProductVersionTxtURL" + + try { + $productVersionResponse = GetHTTPResponse($productVersionTxtUrl) + + if ($productVersionResponse.StatusCode -eq 200) { + $productVersion = $productVersionResponse.Content.ReadAsStringAsync().Result.Trim() + if ($productVersion -ne $SpecificVersion) + { + Say "Using alternate version $productVersion found in $ProductVersionTxtURL" + } + return $productVersion + } + else { + Say-Verbose "Got StatusCode $($productVersionResponse.StatusCode) when trying to get productVersion.txt at $productVersionTxtUrl." + } + } + catch { + Say-Verbose "Could not read productVersion.txt at $productVersionTxtUrl (Exception: '$($_.Exception.Message)'. )" + } } - elseif ($Runtime -eq "aspnetcore") { - $ProductVersionTxtURL = "$AzureFeed/aspnetcore/Runtime/$SpecificVersion/productVersion.txt" + + # Getting the version number with productVersion.txt has failed. Try parsing the download link for a version number. + if ([string]::IsNullOrEmpty($PackageDownloadLink)) + { + Say-Verbose "Using the default value '$SpecificVersion' as the product version." + return $SpecificVersion } - elseif ($Runtime -eq "windowsdesktop") { - $ProductVersionTxtURL = "$AzureFeed/Runtime/$SpecificVersion/productVersion.txt" + + $productVersion = Get-ProductVersionFromDownloadLink $PackageDownloadLink $SpecificVersion + return $productVersion +} + +function Get-Product-Version-Url([string]$AzureFeed, [string]$SpecificVersion, [string]$PackageDownloadLink, [bool]$Flattened) { + Say-Invocation $MyInvocation + + $majorVersion=$null + if ($SpecificVersion -match '^(\d+)\.(.*)') { + $majorVersion = $Matches[1] -as[int] } - elseif (-not $Runtime) { - $ProductVersionTxtURL = "$AzureFeed/Sdk/$SpecificVersion/productVersion.txt" + + $pvFileName='productVersion.txt' + if($Flattened) { + if(-not $Runtime) { + $pvFileName='sdk-productVersion.txt' + } + elseif($Runtime -eq "dotnet") { + $pvFileName='runtime-productVersion.txt' + } + else { + $pvFileName="$Runtime-productVersion.txt" + } + } + + if ([string]::IsNullOrEmpty($PackageDownloadLink)) { + if ($Runtime -eq "dotnet") { + $ProductVersionTxtURL = "$AzureFeed/Runtime/$SpecificVersion/$pvFileName" + } + elseif ($Runtime -eq "aspnetcore") { + $ProductVersionTxtURL = "$AzureFeed/aspnetcore/Runtime/$SpecificVersion/$pvFileName" + } + elseif ($Runtime -eq "windowsdesktop") { + # The windows desktop runtime is part of the core runtime layout prior to 5.0 + $ProductVersionTxtURL = "$AzureFeed/Runtime/$SpecificVersion/$pvFileName" + if ($majorVersion -ne $null -and $majorVersion -ge 5) { + $ProductVersionTxtURL = "$AzureFeed/WindowsDesktop/$SpecificVersion/$pvFileName" + } + } + elseif (-not $Runtime) { + $ProductVersionTxtURL = "$AzureFeed/Sdk/$SpecificVersion/$pvFileName" + } + else { + throw "Invalid value '$Runtime' specified for `$Runtime" + } } else { - throw "Invalid value '$Runtime' specified for `$Runtime" + $ProductVersionTxtURL = $PackageDownloadLink.Substring(0, $PackageDownloadLink.LastIndexOf("/")) + "/$pvFileName" } - Say-Verbose "Checking for existence of $ProductVersionTxtURL" + Say-Verbose "Constructed productVersion link: $ProductVersionTxtURL" - try { - $productVersionResponse = GetHTTPResponse($productVersionTxtUrl) + return $ProductVersionTxtURL +} - if ($productVersionResponse.StatusCode -eq 200) { - $productVersion = $productVersionResponse.Content.ReadAsStringAsync().Result.Trim() - if ($productVersion -ne $SpecificVersion) - { - Say "Using alternate version $productVersion found in $ProductVersionTxtURL" - } +function Get-ProductVersionFromDownloadLink([string]$PackageDownloadLink, [string]$SpecificVersion) +{ + Say-Invocation $MyInvocation - return $productVersion - } - else { - Say-Verbose "Got StatusCode $($productVersionResponse.StatusCode) trying to get productVersion.txt at $productVersionTxtUrl, so using default value of $SpecificVersion" - $productVersion = $SpecificVersion - } - } catch { - Say-Verbose "Could not read productVersion.txt at $productVersionTxtUrl, so using default value of $SpecificVersion (Exception: '$($_.Exception.Message)' )" + #product specific version follows the product name + #for filename 'dotnet-sdk-3.1.404-win-x64.zip': the product version is 3.1.400 + $filename = $PackageDownloadLink.Substring($PackageDownloadLink.LastIndexOf("/") + 1) + $filenameParts = $filename.Split('-') + if ($filenameParts.Length -gt 2) + { + $productVersion = $filenameParts[2] + Say-Verbose "Extracted product version '$productVersion' from download link '$PackageDownloadLink'." + } + else { + Say-Verbose "Using the default value '$SpecificVersion' as the product version." $productVersion = $SpecificVersion } - return $productVersion } @@ -517,7 +757,8 @@ function Get-Absolute-Path([string]$RelativeOrAbsolutePath) { } function Get-Path-Prefix-With-Version($path) { - $match = [regex]::match($path, $VersionRegEx) + # example path with regex: shared/1.0.0-beta-12345/somepath + $match = [regex]::match($path, "/\d+\.\d+[^/]+/") if ($match.Success) { return $entry.FullName.Substring(0, $match.Index + $match.Length) } @@ -531,7 +772,7 @@ function Get-List-Of-Directories-And-Versions-To-Unpack-From-Dotnet-Package([Sys $ret = @() foreach ($entry in $Zip.Entries) { $dir = Get-Path-Prefix-With-Version $entry.FullName - if ($dir -ne $null) { + if ($null -ne $dir) { $path = Get-Absolute-Path $(Join-Path -Path $OutPath -ChildPath $dir) if (-Not (Test-Path $path -PathType Container)) { $ret += $dir @@ -572,7 +813,7 @@ function Extract-Dotnet-Package([string]$ZipPath, [string]$OutPath) { foreach ($entry in $Zip.Entries) { $PathWithVersion = Get-Path-Prefix-With-Version $entry.FullName - if (($PathWithVersion -eq $null) -Or ($DirectoriesToUnpack -contains $PathWithVersion)) { + if (($null -eq $PathWithVersion) -Or ($DirectoriesToUnpack -contains $PathWithVersion)) { $DestinationPath = Get-Absolute-Path $(Join-Path -Path $OutPath -ChildPath $entry.FullName) $DestinationDir = Split-Path -Parent $DestinationPath $OverrideFiles=$OverrideNonVersionedFiles -Or (-Not (Test-Path $DestinationPath)) @@ -583,8 +824,13 @@ function Extract-Dotnet-Package([string]$ZipPath, [string]$OutPath) { } } } + catch + { + Say-Error "Failed to extract package. Exception: $_" + throw; + } finally { - if ($Zip -ne $null) { + if ($null -ne $Zip) { $Zip.Dispose() } } @@ -613,14 +859,31 @@ function DownloadFile($Source, [string]$OutPath) { $File.Close() } finally { - if ($Stream -ne $null) { + if ($null -ne $Stream) { $Stream.Dispose() } } } -function Prepend-Sdk-InstallRoot-To-Path([string]$InstallRoot, [string]$BinFolderRelativePath) { - $BinPath = Get-Absolute-Path $(Join-Path -Path $InstallRoot -ChildPath $BinFolderRelativePath) +function SafeRemoveFile($Path) { + try { + if (Test-Path $Path) { + Remove-Item $Path + Say-Verbose "The temporary file `"$Path`" was removed." + } + else + { + Say-Verbose "The temporary file `"$Path`" does not exist, therefore is not removed." + } + } + catch + { + Say-Warning "Failed to remove the temporary file: `"$Path`", remove it manually." + } +} + +function Prepend-Sdk-InstallRoot-To-Path([string]$InstallRoot) { + $BinPath = Get-Absolute-Path $(Join-Path -Path $InstallRoot -ChildPath "") if (-Not $NoPath) { $SuffixedBinPath = "$BinPath;" if (-Not $env:path.Contains($SuffixedBinPath)) { @@ -635,25 +898,12 @@ function Prepend-Sdk-InstallRoot-To-Path([string]$InstallRoot, [string]$BinFolde } } -Say "Note that the intended use of this script is for Continuous Integration (CI) scenarios, where:" -Say "- The SDK needs to be installed without user interaction and without admin rights." -Say "- The SDK installation doesn't need to persist across multiple CI runs." -Say "To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer.`r`n" - -$CLIArchitecture = Get-CLIArchitecture-From-Architecture $Architecture -$SpecificVersion = Get-Specific-Version-From-Version -AzureFeed $AzureFeed -Channel $Channel -Version $Version -JSonFile $JSonFile -$DownloadLink, $EffectiveVersion = Get-Download-Link -AzureFeed $AzureFeed -SpecificVersion $SpecificVersion -CLIArchitecture $CLIArchitecture -$LegacyDownloadLink = Get-LegacyDownload-Link -AzureFeed $AzureFeed -SpecificVersion $SpecificVersion -CLIArchitecture $CLIArchitecture - -$InstallRoot = Resolve-Installation-Path $InstallDir -Say-Verbose "InstallRoot: $InstallRoot" -$ScriptName = $MyInvocation.MyCommand.Name - -if ($DryRun) { +function PrintDryRunOutput($Invocation, $DownloadLinks) +{ Say "Payload URLs:" - Say "Primary named payload URL: $DownloadLink" - if ($LegacyDownloadLink) { - Say "Legacy named payload URL: $LegacyDownloadLink" + + for ($linkIndex=0; $linkIndex -lt $DownloadLinks.count; $linkIndex++) { + Say "URL #$linkIndex - $($DownloadLinks[$linkIndex].type): $($DownloadLinks[$linkIndex].downloadLink)" } $RepeatableCommand = ".\$ScriptName -Version `"$SpecificVersion`" -InstallDir `"$InstallRoot`" -Architecture `"$CLIArchitecture`"" if ($Runtime -eq "dotnet") { @@ -662,163 +912,415 @@ if ($DryRun) { elseif ($Runtime -eq "aspnetcore") { $RepeatableCommand+=" -Runtime `"aspnetcore`"" } - foreach ($key in $MyInvocation.BoundParameters.Keys) { - if (-not (@("Architecture","Channel","DryRun","InstallDir","Runtime","SharedRuntime","Version") -contains $key)) { - $RepeatableCommand+=" -$key `"$($MyInvocation.BoundParameters[$key])`"" + + foreach ($key in $Invocation.BoundParameters.Keys) { + if (-not (@("Architecture","Channel","DryRun","InstallDir","Runtime","SharedRuntime","Version","Quality","FeedCredential") -contains $key)) { + $RepeatableCommand+=" -$key `"$($Invocation.BoundParameters[$key])`"" } } + if ($Invocation.BoundParameters.Keys -contains "FeedCredential") { + $RepeatableCommand+=" -FeedCredential `"`"" + } Say "Repeatable invocation: $RepeatableCommand" if ($SpecificVersion -ne $EffectiveVersion) { Say "NOTE: Due to finding a version manifest with this runtime, it would actually install with version '$EffectiveVersion'" } +} + +function Get-AkaMSDownloadLink([string]$Channel, [string]$Quality, [bool]$Internal, [string]$Product, [string]$Architecture) { + Say-Invocation $MyInvocation + + #quality is not supported for LTS or STS channel + if (![string]::IsNullOrEmpty($Quality) -and (@("LTS", "STS") -contains $Channel)) { + $Quality = "" + Say-Warning "Specifying quality for STS or LTS channel is not supported, the quality will be ignored." + } + Say-Verbose "Retrieving primary payload URL from aka.ms link for channel: '$Channel', quality: '$Quality' product: '$Product', os: 'win', architecture: '$Architecture'." + + #construct aka.ms link + $akaMsLink = "https://aka.ms/dotnet" + if ($Internal) { + $akaMsLink += "/internal" + } + $akaMsLink += "/$Channel" + if (-not [string]::IsNullOrEmpty($Quality)) { + $akaMsLink +="/$Quality" + } + $akaMsLink +="/$Product-win-$Architecture.zip" + Say-Verbose "Constructed aka.ms link: '$akaMsLink'." + $akaMsDownloadLink=$null + + for ($maxRedirections = 9; $maxRedirections -ge 0; $maxRedirections--) + { + #get HTTP response + #do not pass credentials as a part of the $akaMsLink and do not apply credentials in the GetHTTPResponse function + #otherwise the redirect link would have credentials as well + #it would result in applying credentials twice to the resulting link and thus breaking it, and in echoing credentials to the output as a part of redirect link + $Response= GetHTTPResponse -Uri $akaMsLink -HeaderOnly $true -DisableRedirect $true -DisableFeedCredential $true + Say-Verbose "Received response:`n$Response" + + if ([string]::IsNullOrEmpty($Response)) { + Say-Verbose "The link '$akaMsLink' is not valid: failed to get redirect location. The resource is not available." + return $null + } + + #if HTTP code is 301 (Moved Permanently), the redirect link exists + if ($Response.StatusCode -eq 301) + { + try { + $akaMsDownloadLink = $Response.Headers.GetValues("Location")[0] + + if ([string]::IsNullOrEmpty($akaMsDownloadLink)) { + Say-Verbose "The link '$akaMsLink' is not valid: server returned 301 (Moved Permanently), but the headers do not contain the redirect location." + return $null + } + + Say-Verbose "The redirect location retrieved: '$akaMsDownloadLink'." + # This may yet be a link to another redirection. Attempt to retrieve the page again. + $akaMsLink = $akaMsDownloadLink + continue + } + catch { + Say-Verbose "The link '$akaMsLink' is not valid: failed to get redirect location." + return $null + } + } + elseif ((($Response.StatusCode -lt 300) -or ($Response.StatusCode -ge 400)) -and (-not [string]::IsNullOrEmpty($akaMsDownloadLink))) + { + # Redirections have ended. + return $akaMsDownloadLink + } + + Say-Verbose "The link '$akaMsLink' is not valid: failed to retrieve the redirection location." + return $null + } + + Say-Verbose "Aka.ms links have redirected more than the maximum allowed redirections. This may be caused by a cyclic redirection of aka.ms links." + return $null + +} + +function Get-AkaMsLink-And-Version([string] $NormalizedChannel, [string] $NormalizedQuality, [bool] $Internal, [string] $ProductName, [string] $Architecture) { + $AkaMsDownloadLink = Get-AkaMSDownloadLink -Channel $NormalizedChannel -Quality $NormalizedQuality -Internal $Internal -Product $ProductName -Architecture $Architecture + + if ([string]::IsNullOrEmpty($AkaMsDownloadLink)){ + if (-not [string]::IsNullOrEmpty($NormalizedQuality)) { + # if quality is specified - exit with error - there is no fallback approach + Say-Error "Failed to locate the latest version in the channel '$NormalizedChannel' with '$NormalizedQuality' quality for '$ProductName', os: 'win', architecture: '$Architecture'." + Say-Error "Refer to: https://aka.ms/dotnet-os-lifecycle for information on .NET Core support." + throw "aka.ms link resolution failure" + } + Say-Verbose "Falling back to latest.version file approach." + return ($null, $null, $null) + } + else { + Say-Verbose "Retrieved primary named payload URL from aka.ms link: '$AkaMsDownloadLink'." + Say-Verbose "Downloading using legacy url will not be attempted." + + #get version from the path + $pathParts = $AkaMsDownloadLink.Split('/') + if ($pathParts.Length -ge 2) { + $SpecificVersion = $pathParts[$pathParts.Length - 2] + Say-Verbose "Version: '$SpecificVersion'." + } + else { + Say-Error "Failed to extract the version from download link '$AkaMsDownloadLink'." + return ($null, $null, $null) + } + + #retrieve effective (product) version + $EffectiveVersion = Get-Product-Version -SpecificVersion $SpecificVersion -PackageDownloadLink $AkaMsDownloadLink + Say-Verbose "Product version: '$EffectiveVersion'." + + return ($AkaMsDownloadLink, $SpecificVersion, $EffectiveVersion); + } +} + +function Get-Feeds-To-Use() +{ + $feeds = @( + "https://dotnetcli.azureedge.net/dotnet", + "https://dotnetbuilds.azureedge.net/public" + ) + + if (-not [string]::IsNullOrEmpty($AzureFeed)) { + $feeds = @($AzureFeed) + } + + if ($NoCdn) { + $feeds = @( + "https://dotnetcli.blob.core.windows.net/dotnet", + "https://dotnetbuilds.blob.core.windows.net/public" + ) + + if (-not [string]::IsNullOrEmpty($UncachedFeed)) { + $feeds = @($UncachedFeed) + } + } - exit 0 + return $feeds } -if ($Runtime -eq "dotnet") { - $assetName = ".NET Core Runtime" - $dotnetPackageRelativePath = "shared\Microsoft.NETCore.App" +function Resolve-AssetName-And-RelativePath([string] $Runtime) { + + if ($Runtime -eq "dotnet") { + $assetName = ".NET Core Runtime" + $dotnetPackageRelativePath = "shared\Microsoft.NETCore.App" + } + elseif ($Runtime -eq "aspnetcore") { + $assetName = "ASP.NET Core Runtime" + $dotnetPackageRelativePath = "shared\Microsoft.AspNetCore.App" + } + elseif ($Runtime -eq "windowsdesktop") { + $assetName = ".NET Core Windows Desktop Runtime" + $dotnetPackageRelativePath = "shared\Microsoft.WindowsDesktop.App" + } + elseif (-not $Runtime) { + $assetName = ".NET Core SDK" + $dotnetPackageRelativePath = "sdk" + } + else { + throw "Invalid value for `$Runtime" + } + + return ($assetName, $dotnetPackageRelativePath) } -elseif ($Runtime -eq "aspnetcore") { - $assetName = "ASP.NET Core Runtime" - $dotnetPackageRelativePath = "shared\Microsoft.AspNetCore.App" + +function Prepare-Install-Directory { + New-Item -ItemType Directory -Force -Path $InstallRoot | Out-Null + + $installDrive = $((Get-Item $InstallRoot -Force).PSDrive.Name); + $diskInfo = $null + try{ + $diskInfo = Get-PSDrive -Name $installDrive + } + catch{ + Say-Warning "Failed to check the disk space. Installation will continue, but it may fail if you do not have enough disk space." + } + + if ( ($null -ne $diskInfo) -and ($diskInfo.Free / 1MB -le 100)) { + throw "There is not enough disk space on drive ${installDrive}:" + } } -elseif ($Runtime -eq "windowsdesktop") { - $assetName = ".NET Core Windows Desktop Runtime" - $dotnetPackageRelativePath = "shared\Microsoft.WindowsDesktop.App" + +Say "Note that the intended use of this script is for Continuous Integration (CI) scenarios, where:" +Say "- The SDK needs to be installed without user interaction and without admin rights." +Say "- The SDK installation doesn't need to persist across multiple CI runs." +Say "To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer.`r`n" + +if ($SharedRuntime -and (-not $Runtime)) { + $Runtime = "dotnet" } -elseif (-not $Runtime) { - $assetName = ".NET Core SDK" - $dotnetPackageRelativePath = "sdk" + +$OverrideNonVersionedFiles = !$SkipNonVersionedFiles + +$CLIArchitecture = Get-CLIArchitecture-From-Architecture $Architecture +$NormalizedQuality = Get-NormalizedQuality $Quality +Say-Verbose "Normalized quality: '$NormalizedQuality'" +$NormalizedChannel = Get-NormalizedChannel $Channel +Say-Verbose "Normalized channel: '$NormalizedChannel'" +$NormalizedProduct = Get-NormalizedProduct $Runtime +Say-Verbose "Normalized product: '$NormalizedProduct'" +$FeedCredential = ValidateFeedCredential $FeedCredential + +$InstallRoot = Resolve-Installation-Path $InstallDir +Say-Verbose "InstallRoot: $InstallRoot" +$ScriptName = $MyInvocation.MyCommand.Name +($assetName, $dotnetPackageRelativePath) = Resolve-AssetName-And-RelativePath -Runtime $Runtime + +$feeds = Get-Feeds-To-Use +$DownloadLinks = @() + +if ($Version.ToLowerInvariant() -ne "latest" -and -not [string]::IsNullOrEmpty($Quality)) { + throw "Quality and Version options are not allowed to be specified simultaneously. See https:// learn.microsoft.com/dotnet/core/tools/dotnet-install-script#options for details." } -else { - throw "Invalid value for `$Runtime" + +# aka.ms links can only be used if the user did not request a specific version via the command line or a global.json file. +if ([string]::IsNullOrEmpty($JSonFile) -and ($Version -eq "latest")) { + ($DownloadLink, $SpecificVersion, $EffectiveVersion) = Get-AkaMsLink-And-Version $NormalizedChannel $NormalizedQuality $Internal $NormalizedProduct $CLIArchitecture + + if ($null -ne $DownloadLink) { + $DownloadLinks += New-Object PSObject -Property @{downloadLink="$DownloadLink";specificVersion="$SpecificVersion";effectiveVersion="$EffectiveVersion";type='aka.ms'} + Say-Verbose "Generated aka.ms link $DownloadLink with version $EffectiveVersion" + + if (-Not $DryRun) { + Say-Verbose "Checking if the version $EffectiveVersion is already installed" + if (Is-Dotnet-Package-Installed -InstallRoot $InstallRoot -RelativePathToPackage $dotnetPackageRelativePath -SpecificVersion $EffectiveVersion) + { + Say "$assetName with version '$EffectiveVersion' is already installed." + Prepend-Sdk-InstallRoot-To-Path -InstallRoot $InstallRoot + return + } + } + } } -if ($SpecificVersion -ne $EffectiveVersion) +# Primary and legacy links cannot be used if a quality was specified. +# If we already have an aka.ms link, no need to search the blob feeds. +if ([string]::IsNullOrEmpty($NormalizedQuality) -and 0 -eq $DownloadLinks.count) { - Say "Performing installation checks for effective version: $EffectiveVersion" - $SpecificVersion = $EffectiveVersion -} + foreach ($feed in $feeds) { + try { + $SpecificVersion = Get-Specific-Version-From-Version -AzureFeed $feed -Channel $Channel -Version $Version -JSonFile $JSonFile + $DownloadLink, $EffectiveVersion = Get-Download-Link -AzureFeed $feed -SpecificVersion $SpecificVersion -CLIArchitecture $CLIArchitecture + $LegacyDownloadLink = Get-LegacyDownload-Link -AzureFeed $feed -SpecificVersion $SpecificVersion -CLIArchitecture $CLIArchitecture + + $DownloadLinks += New-Object PSObject -Property @{downloadLink="$DownloadLink";specificVersion="$SpecificVersion";effectiveVersion="$EffectiveVersion";type='primary'} + Say-Verbose "Generated primary link $DownloadLink with version $EffectiveVersion" -# Check if the SDK version is already installed. -$isAssetInstalled = Is-Dotnet-Package-Installed -InstallRoot $InstallRoot -RelativePathToPackage $dotnetPackageRelativePath -SpecificVersion $SpecificVersion -if ($isAssetInstalled) { - Say "$assetName version $SpecificVersion is already installed." - Prepend-Sdk-InstallRoot-To-Path -InstallRoot $InstallRoot -BinFolderRelativePath $BinFolderRelativePath - exit 0 + if (-not [string]::IsNullOrEmpty($LegacyDownloadLink)) { + $DownloadLinks += New-Object PSObject -Property @{downloadLink="$LegacyDownloadLink";specificVersion="$SpecificVersion";effectiveVersion="$EffectiveVersion";type='legacy'} + Say-Verbose "Generated legacy link $LegacyDownloadLink with version $EffectiveVersion" + } + + if (-Not $DryRun) { + Say-Verbose "Checking if the version $EffectiveVersion is already installed" + if (Is-Dotnet-Package-Installed -InstallRoot $InstallRoot -RelativePathToPackage $dotnetPackageRelativePath -SpecificVersion $EffectiveVersion) + { + Say "$assetName with version '$EffectiveVersion' is already installed." + Prepend-Sdk-InstallRoot-To-Path -InstallRoot $InstallRoot + return + } + } + } + catch + { + Say-Verbose "Failed to acquire download links from feed $feed. Exception: $_" + } + } } -New-Item -ItemType Directory -Force -Path $InstallRoot | Out-Null +if ($DownloadLinks.count -eq 0) { + throw "Failed to resolve the exact version number." +} -$installDrive = $((Get-Item $InstallRoot).PSDrive.Name); -$diskInfo = Get-PSDrive -Name $installDrive -if ($diskInfo.Free / 1MB -le 100) { - Say "There is not enough disk space on drive ${installDrive}:" - exit 0 +if ($DryRun) { + PrintDryRunOutput $MyInvocation $DownloadLinks + return } +Prepare-Install-Directory + $ZipPath = [System.IO.Path]::combine([System.IO.Path]::GetTempPath(), [System.IO.Path]::GetRandomFileName()) Say-Verbose "Zip path: $ZipPath" -$DownloadFailed = $false -Say "Downloading link: $DownloadLink" -try { - DownloadFile -Source $DownloadLink -OutPath $ZipPath -} -catch { - Say "Cannot download: $DownloadLink" - if ($LegacyDownloadLink) { - $DownloadLink = $LegacyDownloadLink - $ZipPath = [System.IO.Path]::combine([System.IO.Path]::GetTempPath(), [System.IO.Path]::GetRandomFileName()) - Say-Verbose "Legacy zip path: $ZipPath" - Say "Downloading legacy link: $DownloadLink" - try { - DownloadFile -Source $DownloadLink -OutPath $ZipPath +$DownloadSucceeded = $false +$DownloadedLink = $null +$ErrorMessages = @() + +foreach ($link in $DownloadLinks) +{ + Say-Verbose "Downloading `"$($link.type)`" link $($link.downloadLink)" + + try { + DownloadFile -Source $link.downloadLink -OutPath $ZipPath + Say-Verbose "Download succeeded." + $DownloadSucceeded = $true + $DownloadedLink = $link + break + } + catch { + $StatusCode = $null + $ErrorMessage = $null + + if ($PSItem.Exception.Data.Contains("StatusCode")) { + $StatusCode = $PSItem.Exception.Data["StatusCode"] } - catch { - Say "Cannot download: $DownloadLink" - $DownloadFailed = $true + + if ($PSItem.Exception.Data.Contains("ErrorMessage")) { + $ErrorMessage = $PSItem.Exception.Data["ErrorMessage"] + } else { + $ErrorMessage = $PSItem.Exception.Message } + + Say-Verbose "Download failed with status code $StatusCode. Error message: $ErrorMessage" + $ErrorMessages += "Downloading from `"$($link.type)`" link has failed with error:`nUri: $($link.downloadLink)`nStatusCode: $StatusCode`nError: $ErrorMessage" } - else { - $DownloadFailed = $true - } + + # This link failed. Clean up before trying the next one. + SafeRemoveFile -Path $ZipPath } -if ($DownloadFailed) { - throw "Could not find/download: `"$assetName`" with version = $SpecificVersion`nRefer to: https://aka.ms/dotnet-os-lifecycle for information on .NET Core support" +if (-not $DownloadSucceeded) { + foreach ($ErrorMessage in $ErrorMessages) { + Say-Error $ErrorMessages + } + + throw "Could not find `"$assetName`" with version = $($DownloadLinks[0].effectiveVersion)`nRefer to: https://aka.ms/dotnet-os-lifecycle for information on .NET support" } -Say "Extracting zip from $DownloadLink" +Say "Extracting the archive." Extract-Dotnet-Package -ZipPath $ZipPath -OutPath $InstallRoot # Check if the SDK version is installed; if not, fail the installation. $isAssetInstalled = $false # if the version contains "RTM" or "servicing"; check if a 'release-type' SDK version is installed. -if ($SpecificVersion -Match "rtm" -or $SpecificVersion -Match "servicing") { - $ReleaseVersion = $SpecificVersion.Split("-")[0] +if ($DownloadedLink.effectiveVersion -Match "rtm" -or $DownloadedLink.effectiveVersion -Match "servicing") { + $ReleaseVersion = $DownloadedLink.effectiveVersion.Split("-")[0] Say-Verbose "Checking installation: version = $ReleaseVersion" $isAssetInstalled = Is-Dotnet-Package-Installed -InstallRoot $InstallRoot -RelativePathToPackage $dotnetPackageRelativePath -SpecificVersion $ReleaseVersion } # Check if the SDK version is installed. if (!$isAssetInstalled) { - Say-Verbose "Checking installation: version = $SpecificVersion" - $isAssetInstalled = Is-Dotnet-Package-Installed -InstallRoot $InstallRoot -RelativePathToPackage $dotnetPackageRelativePath -SpecificVersion $SpecificVersion + Say-Verbose "Checking installation: version = $($DownloadedLink.effectiveVersion)" + $isAssetInstalled = Is-Dotnet-Package-Installed -InstallRoot $InstallRoot -RelativePathToPackage $dotnetPackageRelativePath -SpecificVersion $DownloadedLink.effectiveVersion } +# Version verification failed. More likely something is wrong either with the downloaded content or with the verification algorithm. if (!$isAssetInstalled) { - throw "`"$assetName`" with version = $SpecificVersion failed to install with an unknown error." + Say-Error "Failed to verify the version of installed `"$assetName`".`nInstallation source: $($DownloadedLink.downloadLink).`nInstallation location: $InstallRoot.`nReport the bug at https://github.com/dotnet/install-scripts/issues." + throw "`"$assetName`" with version = $($DownloadedLink.effectiveVersion) failed to install with an unknown error." } -Remove-Item $ZipPath +SafeRemoveFile -Path $ZipPath -Prepend-Sdk-InstallRoot-To-Path -InstallRoot $InstallRoot -BinFolderRelativePath $BinFolderRelativePath +Prepend-Sdk-InstallRoot-To-Path -InstallRoot $InstallRoot Say "Note that the script does not resolve dependencies during installation." -Say "To check the list of dependencies, go to https://docs.microsoft.com/dotnet/core/install/windows#dependencies" +Say "To check the list of dependencies, go to https://learn.microsoft.com/dotnet/core/install/windows#dependencies" +Say "Installed version is $($DownloadedLink.effectiveVersion)" Say "Installation finished" -exit 0 + # SIG # Begin signature block -# MIIjlgYJKoZIhvcNAQcCoIIjhzCCI4MCAQExDzANBglghkgBZQMEAgEFADB5Bgor +# MIInzgYJKoZIhvcNAQcCoIInvzCCJ7sCAQExDzANBglghkgBZQMEAgEFADB5Bgor # BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG -# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCA+isugNMwZSGLd -# kfBd0C2Ud//U2Nbj31s1jg3Yf9gh4KCCDYUwggYDMIID66ADAgECAhMzAAABiK9S -# 1rmSbej5AAAAAAGIMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD +# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCB7pzZ0nuEMd30h +# n1EcAYUQN+1clltqaLf9611TDrw/laCCDYUwggYDMIID66ADAgECAhMzAAACzfNk +# v/jUTF1RAAAAAALNMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD # VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy # b3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25p -# bmcgUENBIDIwMTEwHhcNMjAwMzA0MTgzOTQ4WhcNMjEwMzAzMTgzOTQ4WjB0MQsw +# bmcgUENBIDIwMTEwHhcNMjIwNTEyMjA0NjAyWhcNMjMwNTExMjA0NjAyWjB0MQsw # CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u # ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMR4wHAYDVQQDExVNaWNy # b3NvZnQgQ29ycG9yYXRpb24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB -# AQCSCNryE+Cewy2m4t/a74wZ7C9YTwv1PyC4BvM/kSWPNs8n0RTe+FvYfU+E9uf0 -# t7nYlAzHjK+plif2BhD+NgdhIUQ8sVwWO39tjvQRHjP2//vSvIfmmkRoML1Ihnjs -# 9kQiZQzYRDYYRp9xSQYmRwQjk5hl8/U7RgOiQDitVHaU7BT1MI92lfZRuIIDDYBd -# vXtbclYJMVOwqZtv0O9zQCret6R+fRSGaDNfEEpcILL+D7RV3M4uaJE4Ta6KAOdv -# V+MVaJp1YXFTZPKtpjHO6d9pHQPZiG7NdC6QbnRGmsa48uNQrb6AfmLKDI1Lp31W -# MogTaX5tZf+CZT9PSuvjOCLNAgMBAAGjggGCMIIBfjAfBgNVHSUEGDAWBgorBgEE -# AYI3TAgBBggrBgEFBQcDAzAdBgNVHQ4EFgQUj9RJL9zNrPcL10RZdMQIXZN7MG8w +# AQDrIzsY62MmKrzergm7Ucnu+DuSHdgzRZVCIGi9CalFrhwtiK+3FIDzlOYbs/zz +# HwuLC3hir55wVgHoaC4liQwQ60wVyR17EZPa4BQ28C5ARlxqftdp3H8RrXWbVyvQ +# aUnBQVZM73XDyGV1oUPZGHGWtgdqtBUd60VjnFPICSf8pnFiit6hvSxH5IVWI0iO +# nfqdXYoPWUtVUMmVqW1yBX0NtbQlSHIU6hlPvo9/uqKvkjFUFA2LbC9AWQbJmH+1 +# uM0l4nDSKfCqccvdI5l3zjEk9yUSUmh1IQhDFn+5SL2JmnCF0jZEZ4f5HE7ykDP+ +# oiA3Q+fhKCseg+0aEHi+DRPZAgMBAAGjggGCMIIBfjAfBgNVHSUEGDAWBgorBgEE +# AYI3TAgBBggrBgEFBQcDAzAdBgNVHQ4EFgQU0WymH4CP7s1+yQktEwbcLQuR9Zww # VAYDVR0RBE0wS6RJMEcxLTArBgNVBAsTJE1pY3Jvc29mdCBJcmVsYW5kIE9wZXJh -# dGlvbnMgTGltaXRlZDEWMBQGA1UEBRMNMjMwMDEyKzQ1ODM4NjAfBgNVHSMEGDAW +# dGlvbnMgTGltaXRlZDEWMBQGA1UEBRMNMjMwMDEyKzQ3MDUzMDAfBgNVHSMEGDAW # gBRIbmTlUAXTgqoXNzcitW2oynUClTBUBgNVHR8ETTBLMEmgR6BFhkNodHRwOi8v # d3d3Lm1pY3Jvc29mdC5jb20vcGtpb3BzL2NybC9NaWNDb2RTaWdQQ0EyMDExXzIw # MTEtMDctMDguY3JsMGEGCCsGAQUFBwEBBFUwUzBRBggrBgEFBQcwAoZFaHR0cDov # L3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9jZXJ0cy9NaWNDb2RTaWdQQ0EyMDEx # XzIwMTEtMDctMDguY3J0MAwGA1UdEwEB/wQCMAAwDQYJKoZIhvcNAQELBQADggIB -# ACnXo8hjp7FeT+H6iQlV3CcGnkSbFvIpKYafgzYCFo3UHY1VHYJVb5jHEO8oG26Q -# qBELmak6MTI+ra3WKMTGhE1sEIlowTcp4IAs8a5wpCh6Vf4Z/bAtIppP3p3gXk2X -# 8UXTc+WxjQYsDkFiSzo/OBa5hkdW1g4EpO43l9mjToBdqEPtIXsZ7Hi1/6y4gK0P -# mMiwG8LMpSn0n/oSHGjrUNBgHJPxgs63Slf58QGBznuXiRaXmfTUDdrvhRocdxIM -# i8nXQwWACMiQzJSRzBP5S2wUq7nMAqjaTbeXhJqD2SFVHdUYlKruvtPSwbnqSRWT -# GI8s4FEXt+TL3w5JnwVZmZkUFoioQDMMjFyaKurdJ6pnzbr1h6QW0R97fWc8xEIz -# LIOiU2rjwWAtlQqFO8KNiykjYGyEf5LyAJKAO+rJd9fsYR+VBauIEQoYmjnUbTXM -# SY2Lf5KMluWlDOGVh8q6XjmBccpaT+8tCfxpaVYPi1ncnwTwaPQvVq8RjWDRB7Pa -# 8ruHgj2HJFi69+hcq7mWx5nTUtzzFa7RSZfE5a1a5AuBmGNRr7f8cNfa01+tiWjV -# Kk1a+gJUBSP0sIxecFbVSXTZ7bqeal45XSDIisZBkWb+83TbXdTGMDSUFKTAdtC+ -# r35GfsN8QVy59Hb5ZYzAXczhgRmk7NyE6jD0Ym5TKiW5MIIHejCCBWKgAwIBAgIK +# AE7LSuuNObCBWYuttxJAgilXJ92GpyV/fTiyXHZ/9LbzXs/MfKnPwRydlmA2ak0r +# GWLDFh89zAWHFI8t9JLwpd/VRoVE3+WyzTIskdbBnHbf1yjo/+0tpHlnroFJdcDS +# MIsH+T7z3ClY+6WnjSTetpg1Y/pLOLXZpZjYeXQiFwo9G5lzUcSd8YVQNPQAGICl +# 2JRSaCNlzAdIFCF5PNKoXbJtEqDcPZ8oDrM9KdO7TqUE5VqeBe6DggY1sZYnQD+/ +# LWlz5D0wCriNgGQ/TWWexMwwnEqlIwfkIcNFxo0QND/6Ya9DTAUykk2SKGSPt0kL +# tHxNEn2GJvcNtfohVY/b0tuyF05eXE3cdtYZbeGoU1xQixPZAlTdtLmeFNly82uB +# VbybAZ4Ut18F//UrugVQ9UUdK1uYmc+2SdRQQCccKwXGOuYgZ1ULW2u5PyfWxzo4 +# BR++53OB/tZXQpz4OkgBZeqs9YaYLFfKRlQHVtmQghFHzB5v/WFonxDVlvPxy2go +# a0u9Z+ZlIpvooZRvm6OtXxdAjMBcWBAsnBRr/Oj5s356EDdf2l/sLwLFYE61t+ME +# iNYdy0pXL6gN3DxTVf2qjJxXFkFfjjTisndudHsguEMk8mEtnvwo9fOSKT6oRHhM +# 9sZ4HTg/TTMjUljmN3mBYWAWI5ExdC1inuog0xrKmOWVMIIHejCCBWKgAwIBAgIK # YQ6Q0gAAAAAAAzANBgkqhkiG9w0BAQsFADCBiDELMAkGA1UEBhMCVVMxEzARBgNV # BAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jv # c29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlm @@ -858,119 +1360,142 @@ exit 0 # BL7fQccOKO7eZS/sl/ahXJbYANahRr1Z85elCUtIEJmAH9AAKcWxm6U/RXceNcbS # oqKfenoi+kiVH6v7RyOA9Z74v2u3S5fi63V4GuzqN5l5GEv/1rMjaHXmr/r8i+sL # gOppO6/8MO0ETI7f33VtY5E90Z1WTk+/gFcioXgRMiF670EKsT/7qMykXcGhiJtX -# cVZOSEXAQsmbdlsKgEhr/Xmfwb1tbWrJUnMTDXpQzTGCFWcwghVjAgEBMIGVMH4x +# cVZOSEXAQsmbdlsKgEhr/Xmfwb1tbWrJUnMTDXpQzTGCGZ8wghmbAgEBMIGVMH4x # CzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRt # b25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01p -# Y3Jvc29mdCBDb2RlIFNpZ25pbmcgUENBIDIwMTECEzMAAAGIr1LWuZJt6PkAAAAA -# AYgwDQYJYIZIAWUDBAIBBQCgga4wGQYJKoZIhvcNAQkDMQwGCisGAQQBgjcCAQQw -# HAYKKwYBBAGCNwIBCzEOMAwGCisGAQQBgjcCARUwLwYJKoZIhvcNAQkEMSIEIK4I -# CDH7/r/eeMqTtDETJ67ogfneVRo0/P6ogV2vy4tXMEIGCisGAQQBgjcCAQwxNDAy +# Y3Jvc29mdCBDb2RlIFNpZ25pbmcgUENBIDIwMTECEzMAAALN82S/+NRMXVEAAAAA +# As0wDQYJYIZIAWUDBAIBBQCgga4wGQYJKoZIhvcNAQkDMQwGCisGAQQBgjcCAQQw +# HAYKKwYBBAGCNwIBCzEOMAwGCisGAQQBgjcCARUwLwYJKoZIhvcNAQkEMSIEINK7 +# cJe0KVfbcXchjID30U/cUg7pWAQUa3+n8JuhjLCLMEIGCisGAQQBgjcCAQwxNDAy # oBSAEgBNAGkAYwByAG8AcwBvAGYAdKEagBhodHRwOi8vd3d3Lm1pY3Jvc29mdC5j -# b20wDQYJKoZIhvcNAQEBBQAEggEAOnmVmILEjI6ZiuuSOvvTvijidkBez61Vz97A -# jV3AOsfmUvLpVaTVa1Mt2iPDuq1QLqRPaT7BD8PAUwr91pYllVgEd8NqivCIaCZg -# QyIRiTmHQxbozWsLcjxMvX2VxSmNKDw7IOHzUbXtmiEGhygyZpdh/uiCj7ziSxp3 -# lQBR8mUE1NL9dxaxKWLhGeORqAepw6nId9oO+mHRh4JRK7uqZOFAES7/21M9vPZi -# XYilJLgIoyMkvqYSdoouzn6+m74kgzkNkyK9GYz2mmO2BCMnai9Njze2d0+kY+37 -# kt10BmJDw3FHaZ+/fH/TMTgo0ZcAOicP9ccdIh/CzzpU52o+Q6GCEvEwghLtBgor -# BgEEAYI3AwMBMYIS3TCCEtkGCSqGSIb3DQEHAqCCEsowghLGAgEDMQ8wDQYJYIZI -# AWUDBAIBBQAwggFVBgsqhkiG9w0BCRABBKCCAUQEggFAMIIBPAIBAQYKKwYBBAGE -# WQoDATAxMA0GCWCGSAFlAwQCAQUABCBSbhMJwNER+BICn3iLUnPrP8dptyUphcFC -# A/NsIgnPLwIGX4hEzP6WGBMyMDIwMTEwOTE0NDY1Mi4yMzNaMASAAgH0oIHUpIHR -# MIHOMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMH -# UmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSkwJwYDVQQL -# EyBNaWNyb3NvZnQgT3BlcmF0aW9ucyBQdWVydG8gUmljbzEmMCQGA1UECxMdVGhh -# bGVzIFRTUyBFU046MEE1Ni1FMzI5LTRENEQxJTAjBgNVBAMTHE1pY3Jvc29mdCBU -# aW1lLVN0YW1wIFNlcnZpY2Wggg5EMIIE9TCCA92gAwIBAgITMwAAAScvbqPvkagZ -# qAAAAAABJzANBgkqhkiG9w0BAQsFADB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMK -# V2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0 -# IENvcnBvcmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0Eg -# MjAxMDAeFw0xOTEyMTkwMTE0NTlaFw0yMTAzMTcwMTE0NTlaMIHOMQswCQYDVQQG -# EwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwG -# A1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSkwJwYDVQQLEyBNaWNyb3NvZnQg -# T3BlcmF0aW9ucyBQdWVydG8gUmljbzEmMCQGA1UECxMdVGhhbGVzIFRTUyBFU046 -# MEE1Ni1FMzI5LTRENEQxJTAjBgNVBAMTHE1pY3Jvc29mdCBUaW1lLVN0YW1wIFNl -# cnZpY2UwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQD4Ad5xEZ5On0uN -# L71ng9xwoDPRKeMUyEIj5yVxPRPh5GVbU7D3pqDsoXzQMhfeRP61L1zlU1HCRS+1 -# 29eo0yj1zjbAlmPAwosUgyIonesWt9E4hFlXCGUcIg5XMdvQ+Ouzk2r+awNRuk8A -# BGOa0I4VBy6zqCYHyX2pGauiB43frJSNP6pcrO0CBmpBZNjgepof5Z/50vBuJDUS -# ug6OIMQ7ZwUhSzX4bEmZUUjAycBb62dhQpGqHsXe6ypVDTgAEnGONdSBKkHiNT8H -# 0Zt2lm0vCLwHyTwtgIdi67T/LCp+X2mlPHqXsY3u72X3GYn/3G8YFCkrSc6m3b0w -# TXPd5/2fAgMBAAGjggEbMIIBFzAdBgNVHQ4EFgQU5fSWVYBfOTEkW2JTiV24WNNt -# lfIwHwYDVR0jBBgwFoAU1WM6XIoxkPNDe3xGG8UzaFqFbVUwVgYDVR0fBE8wTTBL -# oEmgR4ZFaHR0cDovL2NybC5taWNyb3NvZnQuY29tL3BraS9jcmwvcHJvZHVjdHMv -# TWljVGltU3RhUENBXzIwMTAtMDctMDEuY3JsMFoGCCsGAQUFBwEBBE4wTDBKBggr -# BgEFBQcwAoY+aHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraS9jZXJ0cy9NaWNU -# aW1TdGFQQ0FfMjAxMC0wNy0wMS5jcnQwDAYDVR0TAQH/BAIwADATBgNVHSUEDDAK -# BggrBgEFBQcDCDANBgkqhkiG9w0BAQsFAAOCAQEACsqNfNFVxwalZ42cEMuzZc12 -# 6Nvluanx8UewDVeUQZEZHRmppMFHAzS/g6RzmxTyR2tKE3mChNGW5dTL730vEbRh -# nYRmBgiX/gT3f4AQrOPnZGXY7zszcrlbgzxpakOX+x0u4rkP3Ashh3B2CdJ11XsB -# di5PiZa1spB6U5S8D15gqTUfoIniLT4v1DBdkWExsKI1vsiFcDcjGJ4xRlMRF+fw -# 7SY0WZoOzwRzKxDTdg4DusAXpaeKbch9iithLFk/vIxQrqCr/niW8tEA+eSzeX/E -# q1D0ZyvOn4e2lTnwoJUKH6OQAWSBogyK4OCbFeJOqdKAUiBTgHKkQIYh/tbKQjCC -# BnEwggRZoAMCAQICCmEJgSoAAAAAAAIwDQYJKoZIhvcNAQELBQAwgYgxCzAJBgNV -# BAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4w -# HAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xMjAwBgNVBAMTKU1pY3Jvc29m -# dCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAyMDEwMB4XDTEwMDcwMTIxMzY1 -# NVoXDTI1MDcwMTIxNDY1NVowfDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hp -# bmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jw -# b3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAgUENBIDIwMTAw -# ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCpHQ28dxGKOiDs/BOX9fp/ -# aZRrdFQQ1aUKAIKF++18aEssX8XD5WHCdrc+Zitb8BVTJwQxH0EbGpUdzgkTjnxh -# MFmxMEQP8WCIhFRDDNdNuDgIs0Ldk6zWczBXJoKjRQ3Q6vVHgc2/JGAyWGBG8lhH -# hjKEHnRhZ5FfgVSxz5NMksHEpl3RYRNuKMYa+YaAu99h/EbBJx0kZxJyGiGKr0tk -# iVBisV39dx898Fd1rL2KQk1AUdEPnAY+Z3/1ZsADlkR+79BL/W7lmsqxqPJ6Kgox -# 8NpOBpG2iAg16HgcsOmZzTznL0S6p/TcZL2kAcEgCZN4zfy8wMlEXV4WnAEFTyJN -# AgMBAAGjggHmMIIB4jAQBgkrBgEEAYI3FQEEAwIBADAdBgNVHQ4EFgQU1WM6XIox -# kPNDe3xGG8UzaFqFbVUwGQYJKwYBBAGCNxQCBAweCgBTAHUAYgBDAEEwCwYDVR0P -# BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAU1fZWy4/oolxiaNE9 -# lJBb186aGMQwVgYDVR0fBE8wTTBLoEmgR4ZFaHR0cDovL2NybC5taWNyb3NvZnQu -# Y29tL3BraS9jcmwvcHJvZHVjdHMvTWljUm9vQ2VyQXV0XzIwMTAtMDYtMjMuY3Js -# MFoGCCsGAQUFBwEBBE4wTDBKBggrBgEFBQcwAoY+aHR0cDovL3d3dy5taWNyb3Nv -# ZnQuY29tL3BraS9jZXJ0cy9NaWNSb29DZXJBdXRfMjAxMC0wNi0yMy5jcnQwgaAG -# A1UdIAEB/wSBlTCBkjCBjwYJKwYBBAGCNy4DMIGBMD0GCCsGAQUFBwIBFjFodHRw -# Oi8vd3d3Lm1pY3Jvc29mdC5jb20vUEtJL2RvY3MvQ1BTL2RlZmF1bHQuaHRtMEAG -# CCsGAQUFBwICMDQeMiAdAEwAZQBnAGEAbABfAFAAbwBsAGkAYwB5AF8AUwB0AGEA -# dABlAG0AZQBuAHQALiAdMA0GCSqGSIb3DQEBCwUAA4ICAQAH5ohRDeLG4Jg/gXED -# PZ2joSFvs+umzPUxvs8F4qn++ldtGTCzwsVmyWrf9efweL3HqJ4l4/m87WtUVwgr -# UYJEEvu5U4zM9GASinbMQEBBm9xcF/9c+V4XNZgkVkt070IQyK+/f8Z/8jd9Wj8c -# 8pl5SpFSAK84Dxf1L3mBZdmptWvkx872ynoAb0swRCQiPM/tA6WWj1kpvLb9BOFw -# nzJKJ/1Vry/+tuWOM7tiX5rbV0Dp8c6ZZpCM/2pif93FSguRJuI57BlKcWOdeyFt -# w5yjojz6f32WapB4pm3S4Zz5Hfw42JT0xqUKloakvZ4argRCg7i1gJsiOCC1JeVk -# 7Pf0v35jWSUPei45V3aicaoGig+JFrphpxHLmtgOR5qAxdDNp9DvfYPw4TtxCd9d -# dJgiCGHasFAeb73x4QDf5zEHpJM692VHeOj4qEir995yfmFrb3epgcunCaw5u+zG -# y9iCtHLNHfS4hQEegPsbiSpUObJb2sgNVZl6h3M7COaYLeqN4DMuEin1wC9UJyH3 -# yKxO2ii4sanblrKnQqLJzxlBTeCG+SqaoxFmMNO7dDJL32N79ZmKLxvHIa9Zta7c -# RDyXUHHXodLFVeNp3lfB0d4wwP3M5k37Db9dT+mdHhk4L7zPWAUu7w2gUDXa7wkn -# HNWzfjUeCLraNtvTX4/edIhJEqGCAtIwggI7AgEBMIH8oYHUpIHRMIHOMQswCQYD -# VQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEe -# MBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSkwJwYDVQQLEyBNaWNyb3Nv -# ZnQgT3BlcmF0aW9ucyBQdWVydG8gUmljbzEmMCQGA1UECxMdVGhhbGVzIFRTUyBF -# U046MEE1Ni1FMzI5LTRENEQxJTAjBgNVBAMTHE1pY3Jvc29mdCBUaW1lLVN0YW1w -# IFNlcnZpY2WiIwoBATAHBgUrDgMCGgMVALOVuE5sgxzETO4s+poBqI6r1x8zoIGD -# MIGApH4wfDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNV -# BAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEmMCQG -# A1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAgUENBIDIwMTAwDQYJKoZIhvcNAQEF -# BQACBQDjU7byMCIYDzIwMjAxMTA5MTYzOTE0WhgPMjAyMDExMTAxNjM5MTRaMHcw -# PQYKKwYBBAGEWQoEATEvMC0wCgIFAONTtvICAQAwCgIBAAICIt0CAf8wBwIBAAIC -# EcQwCgIFAONVCHICAQAwNgYKKwYBBAGEWQoEAjEoMCYwDAYKKwYBBAGEWQoDAqAK -# MAgCAQACAwehIKEKMAgCAQACAwGGoDANBgkqhkiG9w0BAQUFAAOBgQAQhyIIAC/A -# P+VJdbhL9IQgm8WTa1DmPPE+BQSuRbBy2MmzC1KostixdEkr2OaNSjcYuZBNIJgv -# vE8CWhVDD+sbBpVcOdoSfoBwHXKfvqSTiWvovoexkF0X5aon7yr3PkJ/kEqoLyUM -# xRvdWKJdHOL1sT0/aWHn048c6aGin/zc8DGCAw0wggMJAgEBMIGTMHwxCzAJBgNV -# BAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4w -# HAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xJjAkBgNVBAMTHU1pY3Jvc29m -# dCBUaW1lLVN0YW1wIFBDQSAyMDEwAhMzAAABJy9uo++RqBmoAAAAAAEnMA0GCWCG -# SAFlAwQCAQUAoIIBSjAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwLwYJKoZI -# hvcNAQkEMSIEIJZkrbvF4R8oqYYpN6ZPGOj+QEZTQriEi/Yw9gW6zMqRMIH6Bgsq -# hkiG9w0BCRACLzGB6jCB5zCB5DCBvQQgG5LoSxKGHWoW/wVMlbMztlQ4upAdzEmq -# H//vLu0jPiIwgZgwgYCkfjB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGlu +# b20wDQYJKoZIhvcNAQEBBQAEggEAODLxcflOtjpIXXIhbYyQ0wFeBx0NrmoMU/Ri +# e7CRrAieAbG4iLJzs4DhUov5iuMHY6AAbLWAH54QlSkd4XNp6POsE7lSzN9yjlVw +# V/e0XCaYeXIbtd75hGd5P7wAhM4m2ViDI4IRHyQtjysW0U0F6YiqNlFm7Fzo5Si6 +# l2XxvuEDSdyJcEN70wHQajx6bKfnI/oMY59iGjDXvDP/6cQV9NI0gPHFTwPKA7vg +# PySyVFEG7dQMoEwAWy9GHbcS//RulgUwBhWcrtUP411XLSO6is2VTknwbdglc9HZ +# zViuS4C1ujHlPrlMzm8Y5iGVIQCna5w2NU/kGsSK5+dMkovomKGCFykwghclBgor +# BgEEAYI3AwMBMYIXFTCCFxEGCSqGSIb3DQEHAqCCFwIwghb+AgEDMQ8wDQYJYIZI +# AWUDBAIBBQAwggFZBgsqhkiG9w0BCRABBKCCAUgEggFEMIIBQAIBAQYKKwYBBAGE +# WQoDATAxMA0GCWCGSAFlAwQCAQUABCDRz6ce9oWlH6+o0BtjmAjtvEMN1hfhIA5v +# +wTZHvB4XgIGY2PeyIloGBMyMDIyMTExMDE1MDUxNi43MzRaMASAAgH0oIHYpIHV +# MIHSMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMH +# UmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMS0wKwYDVQQL +# EyRNaWNyb3NvZnQgSXJlbGFuZCBPcGVyYXRpb25zIExpbWl0ZWQxJjAkBgNVBAsT +# HVRoYWxlcyBUU1MgRVNOOkEyNDAtNEI4Mi0xMzBFMSUwIwYDVQQDExxNaWNyb3Nv +# ZnQgVGltZS1TdGFtcCBTZXJ2aWNloIIReDCCBycwggUPoAMCAQICEzMAAAG4CNTB +# uHngUUkAAQAAAbgwDQYJKoZIhvcNAQELBQAwfDELMAkGA1UEBhMCVVMxEzARBgNV +# BAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jv +# c29mdCBDb3Jwb3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAg +# UENBIDIwMTAwHhcNMjIwOTIwMjAyMjE2WhcNMjMxMjE0MjAyMjE2WjCB0jELMAkG +# A1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQx +# HjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEtMCsGA1UECxMkTWljcm9z +# b2Z0IElyZWxhbmQgT3BlcmF0aW9ucyBMaW1pdGVkMSYwJAYDVQQLEx1UaGFsZXMg +# VFNTIEVTTjpBMjQwLTRCODItMTMwRTElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUt +# U3RhbXAgU2VydmljZTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAJwb +# sfwRHERn5C95QPGn37tJ5vOiY9aWjeIDxpgaXaYGiqsw0G0cvCK3YulrqemEf2Ck +# GSdcOJAF++EqhOSqrO13nGcjqw6hFNnsGwKANyzddwnOO0jz1lfBIIu77TbfNvna +# WbwSRu0DTGHA7n7PR0MYJ9bC/HopStpbFf606LKcTWnwaUuEdAhx6FAqg1rkgugi +# uuaaxKyxRkdjFZLKFXEXL9p01PtwS0fG6vZiRVnEKgeal2TeLvdAIqapBwltPYif +# gqnp7Z4VJMcPo0TWmRNVFOcHRNwWHehN9xg6ugIGXPo7hMpWrPgg4moHO2epc0T3 +# 6rgm9hlDrl28bG5TakmV7NJ98kbF5lgtlrowT6ecwEVtuLd4a0gzYqhanW7zaFZn +# Dft5yMexy59ifETdzpwArj2nJAyIsiq1PY3XPm2mUMLlACksqelHKfWihK/Fehw/ +# mziovBVwkkr/G0F19OWgR+MBUKifwpOyQiLAxrqvVnfCY4QjJCZiHIuS15HCQ/TI +# t/Qj4x1WvRa1UqjnmpLu4/yBYWZsdvZoq8SXI7iOs7muecAJeEkYlM6iOkMighzE +# hjQK9ThPpoAtluXbL7qIHGrfFlHmX/4soc7jj1j8uB31U34gJlB2XphjMaT+E+O9 +# SImk/6GRV9Sm8C88Fnmm2VdwMluCNAUzPFjfvHx3AgMBAAGjggFJMIIBRTAdBgNV +# HQ4EFgQUxP1HJTeFwzNYo1njfucXuUfQaW4wHwYDVR0jBBgwFoAUn6cVXQBeYl2D +# 9OXSZacbUzUZ6XIwXwYDVR0fBFgwVjBUoFKgUIZOaHR0cDovL3d3dy5taWNyb3Nv +# ZnQuY29tL3BraW9wcy9jcmwvTWljcm9zb2Z0JTIwVGltZS1TdGFtcCUyMFBDQSUy +# MDIwMTAoMSkuY3JsMGwGCCsGAQUFBwEBBGAwXjBcBggrBgEFBQcwAoZQaHR0cDov +# L3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9jZXJ0cy9NaWNyb3NvZnQlMjBUaW1l +# LVN0YW1wJTIwUENBJTIwMjAxMCgxKS5jcnQwDAYDVR0TAQH/BAIwADAWBgNVHSUB +# Af8EDDAKBggrBgEFBQcDCDAOBgNVHQ8BAf8EBAMCB4AwDQYJKoZIhvcNAQELBQAD +# ggIBAJ9uk8miwpMoKw3D996piEzbegAGxkABHYn2vP2hbqnkS9U97s/6QlyZOhGF +# sVudaiLeRZZTsaG5hR0oCuBINZ/lelo5xzHc+mBOpBXpxSaW1hqoxaCLsVH1EBtz +# 7in25Hjy+ejuBcilH6EZ0ZtNxmWGIQz8R0AuS0Tj4VgJXHIlXP9dVOiyGo9Velrk +# +FGx/BC+iEuCaKd/IsypHPiCUCh52DGc91s2S7ldQx1H4CljOAtanDfbvSejASWL +# o/s3w0XMAbDurWNns0XidAF2RnL1PaxoOyz9VYakNGK4F3/uJRZnVgbsCYuwNX1B +# mSwM1ZbPSnggNSGTZx/FQ20Jj/ulrK0ryAbvNbNb4kkaS4a767ifCqvUOFLlUT8P +# N43hhldxI6yHPMOWItJpEHIZBiTNKblBsYbIrghb1Ym9tfSsLa5ZJDzVZNndRfhU +# qJOyXF+CVm9OtVmFDG9kIwM6QAX8Q0if721z4VOzZNvD8ktg1lI+XjXgXDJVs3h4 +# 7sMu9GXSYzky+7dtgmc3iRPkda3YVRdmPJtNFN0NLybcssE7vhFCij75eDGQBFq0 +# A4KVG6uBdr6UTWwE0VKHxBz2BpGvn7BCs+5yxnF+HV6CUickDqqPi/II7Zssd9Eb +# P9uzj4luldXDAPrWGtdGq+wK0odlGNVuCMxsL3hn8+KiO9UiMIIHcTCCBVmgAwIB +# AgITMwAAABXF52ueAptJmQAAAAAAFTANBgkqhkiG9w0BAQsFADCBiDELMAkGA1UE +# BhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAc +# BgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0 +# IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTAwHhcNMjEwOTMwMTgyMjI1 +# WhcNMzAwOTMwMTgzMjI1WjB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGlu +# Z3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBv +# cmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMDCC +# AiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAOThpkzntHIhC3miy9ckeb0O +# 1YLT/e6cBwfSqWxOdcjKNVf2AX9sSuDivbk+F2Az/1xPx2b3lVNxWuJ+Slr+uDZn +# hUYjDLWNE893MsAQGOhgfWpSg0S3po5GawcU88V29YZQ3MFEyHFcUTE3oAo4bo3t +# 1w/YJlN8OWECesSq/XJprx2rrPY2vjUmZNqYO7oaezOtgFt+jBAcnVL+tuhiJdxq +# D89d9P6OU8/W7IVWTe/dvI2k45GPsjksUZzpcGkNyjYtcI4xyDUoveO0hyTD4MmP +# frVUj9z6BVWYbWg7mka97aSueik3rMvrg0XnRm7KMtXAhjBcTyziYrLNueKNiOSW +# rAFKu75xqRdbZ2De+JKRHh09/SDPc31BmkZ1zcRfNN0Sidb9pSB9fvzZnkXftnIv +# 231fgLrbqn427DZM9ituqBJR6L8FA6PRc6ZNN3SUHDSCD/AQ8rdHGO2n6Jl8P0zb +# r17C89XYcz1DTsEzOUyOArxCaC4Q6oRRRuLRvWoYWmEBc8pnol7XKHYC4jMYcten +# IPDC+hIK12NvDMk2ZItboKaDIV1fMHSRlJTYuVD5C4lh8zYGNRiER9vcG9H9stQc +# xWv2XFJRXRLbJbqvUAV6bMURHXLvjflSxIUXk8A8FdsaN8cIFRg/eKtFtvUeh17a +# j54WcmnGrnu3tz5q4i6tAgMBAAGjggHdMIIB2TASBgkrBgEEAYI3FQEEBQIDAQAB +# MCMGCSsGAQQBgjcVAgQWBBQqp1L+ZMSavoKRPEY1Kc8Q/y8E7jAdBgNVHQ4EFgQU +# n6cVXQBeYl2D9OXSZacbUzUZ6XIwXAYDVR0gBFUwUzBRBgwrBgEEAYI3TIN9AQEw +# QTA/BggrBgEFBQcCARYzaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9E +# b2NzL1JlcG9zaXRvcnkuaHRtMBMGA1UdJQQMMAoGCCsGAQUFBwMIMBkGCSsGAQQB +# gjcUAgQMHgoAUwB1AGIAQwBBMAsGA1UdDwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/ +# MB8GA1UdIwQYMBaAFNX2VsuP6KJcYmjRPZSQW9fOmhjEMFYGA1UdHwRPME0wS6BJ +# oEeGRWh0dHA6Ly9jcmwubWljcm9zb2Z0LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01p +# Y1Jvb0NlckF1dF8yMDEwLTA2LTIzLmNybDBaBggrBgEFBQcBAQROMEwwSgYIKwYB +# BQUHMAKGPmh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9wa2kvY2VydHMvTWljUm9v +# Q2VyQXV0XzIwMTAtMDYtMjMuY3J0MA0GCSqGSIb3DQEBCwUAA4ICAQCdVX38Kq3h +# LB9nATEkW+Geckv8qW/qXBS2Pk5HZHixBpOXPTEztTnXwnE2P9pkbHzQdTltuw8x +# 5MKP+2zRoZQYIu7pZmc6U03dmLq2HnjYNi6cqYJWAAOwBb6J6Gngugnue99qb74p +# y27YP0h1AdkY3m2CDPVtI1TkeFN1JFe53Z/zjj3G82jfZfakVqr3lbYoVSfQJL1A +# oL8ZthISEV09J+BAljis9/kpicO8F7BUhUKz/AyeixmJ5/ALaoHCgRlCGVJ1ijbC +# HcNhcy4sa3tuPywJeBTpkbKpW99Jo3QMvOyRgNI95ko+ZjtPu4b6MhrZlvSP9pEB +# 9s7GdP32THJvEKt1MMU0sHrYUP4KWN1APMdUbZ1jdEgssU5HLcEUBHG/ZPkkvnNt +# yo4JvbMBV0lUZNlz138eW0QBjloZkWsNn6Qo3GcZKCS6OEuabvshVGtqRRFHqfG3 +# rsjoiV5PndLQTHa1V1QJsWkBRH58oWFsc/4Ku+xBZj1p/cvBQUl+fpO+y/g75LcV +# v7TOPqUxUYS8vwLBgqJ7Fx0ViY1w/ue10CgaiQuPNtq6TPmb/wrpNPgkNWcr4A24 +# 5oyZ1uEi6vAnQj0llOZ0dFtq0Z4+7X6gMTN9vMvpe784cETRkPHIqzqKOghif9lw +# Y1NNje6CbaUFEMFxBmoQtB1VM1izoXBm8qGCAtQwggI9AgEBMIIBAKGB2KSB1TCB +# 0jELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1Jl +# ZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEtMCsGA1UECxMk +# TWljcm9zb2Z0IElyZWxhbmQgT3BlcmF0aW9ucyBMaW1pdGVkMSYwJAYDVQQLEx1U +# aGFsZXMgVFNTIEVTTjpBMjQwLTRCODItMTMwRTElMCMGA1UEAxMcTWljcm9zb2Z0 +# IFRpbWUtU3RhbXAgU2VydmljZaIjCgEBMAcGBSsOAwIaAxUAcGteVqFx/IbTKXHL +# euXCPRPMD7uggYMwgYCkfjB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGlu # Z3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBv -# cmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMAIT -# MwAAAScvbqPvkagZqAAAAAABJzAiBCDwhEViCRvqKwQV3MxociF2iGYrDP4p1BK+ -# s4tStO4vSDANBgkqhkiG9w0BAQsFAASCAQAkgmDo8lVmar0ZIqTG1it3skG8PZC9 -# iqEEC1vxcz8OSfsjl2QSkQ5T2+3xWpxWA4uy2+Byv0bi8EsfQEnnn4vtdthS6/kb -# vB/LLQiqoMhJ0rasf3/y/4KnQZEtztpg1+cCaNwFUgI6o+E8YEFt1frhLwFs/0WH -# 5pyBFx9ECEs0M22SLIpW13gexv9fgk6ZboIfSreAI28DLveeJpkgwggxHRpuVOVD -# 4D7QQJAvJ0VU6p+yJlbvQXR9iltwb1REhlsJ5mADJ/FkzPVX/swMSUIoyE2inlxK -# LEiPkkZYwiFYCifFYUTnQjWU1Ls0EV+ysosL+jhzCxO8S6oRdp5TAi4F +# cmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMDAN +# BgkqhkiG9w0BAQUFAAIFAOcW7qowIhgPMjAyMjExMTAxMTI5NDZaGA8yMDIyMTEx +# MTExMjk0NlowdDA6BgorBgEEAYRZCgQBMSwwKjAKAgUA5xbuqgIBADAHAgEAAgIE +# qTAHAgEAAgIRVjAKAgUA5xhAKgIBADA2BgorBgEEAYRZCgQCMSgwJjAMBgorBgEE +# AYRZCgMCoAowCAIBAAIDB6EgoQowCAIBAAIDAYagMA0GCSqGSIb3DQEBBQUAA4GB +# AGsU2HTQg158bHX+QngoY7NVfCbGRaLjQOi8geKi26qQWAxll9QLFg4+epiG2nZB +# eQvhxeNmIzounhWfJ+gfhFMi8aBT5z4dLK9iBtmpG1Y14RmSS4andiUlS6bVNVNe +# WGObqHijMVeMOphiTaAfzR6zSASDaG0CfVm9bNBOnZZsMYIEDTCCBAkCAQEwgZMw +# fDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1Jl +# ZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEmMCQGA1UEAxMd +# TWljcm9zb2Z0IFRpbWUtU3RhbXAgUENBIDIwMTACEzMAAAG4CNTBuHngUUkAAQAA +# AbgwDQYJYIZIAWUDBAIBBQCgggFKMBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRAB +# BDAvBgkqhkiG9w0BCQQxIgQg578XwPrBwneU95xu1sHFncHeCC0UPQ7QK7PvSSby +# VpwwgfoGCyqGSIb3DQEJEAIvMYHqMIHnMIHkMIG9BCAo69Y4oHA7Q4pS+Y1NsBfr +# pIYTeWsPeGTami0X0PD7HzCBmDCBgKR+MHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQI +# EwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3Nv +# ZnQgQ29ycG9yYXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBD +# QSAyMDEwAhMzAAABuAjUwbh54FFJAAEAAAG4MCIEIJVlMK4mQfdJaAZx7Unfka/I +# D4Wbw5edh/SR7TTptzRqMA0GCSqGSIb3DQEBCwUABIICAA1QlR3ywR7e+jqZ++NC +# xsIwREiwVS70CEkbH8XpPRS0mFS0SHcCfpwymGfdep3D0CWk0PIfMhXq0SD97iBI +# rOLdHglVBkMYTjGEBHyBzv/LevAZUuzoc5aqyIF4Ywa5KS4PGbMSuRK5CKAojOzH +# A/vp2/KYuADmf9kOOgOfDVicyfoqZ+3W+QaUI/k0KKV4dPLF55+y18C+Td6sR60Y +# AkcvGZObuj/OkREhdTJ1qJ2E/4RKG8gtGY1DfluLon7+UvS/ciWDWrJnHMmkxM11 +# cYuRIvLArIdq/YS2bcSnY6AVO2zYjj7gCqDN9GuCurstUKC5uxVl3VNxntC0u3Le +# BoI/R5uMYlTXodW8ukLNL6zHrQ4wI4udgW77KJref+3E1PEpZBRMxwose7Vt8lDc +# sW1vdM+eZzUXRLhDR8a0Nai7+PaNoukoGf4pvwsu8Mkeji5a0hWtU9lUVRv6nzue +# 3L2olhsbiHhAET7N6Rj0kzEhbUgfVUJrGvNlWOfN7MDr+OpArGXMPLtovbKTLtXF +# v/GrJo9wQuyqUmY6KQSRDZgOw1CcoZpJcy40HG/aOlJwk03N13OZD5H3KfHwEphR +# YnbGwGq9zUId5druSr5s40Yyl3idAkqmI5SXAm9v/gRq2X9vMU0a7KqXet9wO62F +# TqxV+7Qp48Vw6hW1g+Q7oWoc # SIG # End signature block diff --git a/tools/dotnet-install.sh b/tools/dotnet-install.sh index 6525339be..5327f34e0 100755 --- a/tools/dotnet-install.sh +++ b/tools/dotnet-install.sh @@ -24,7 +24,7 @@ exec 3>&1 # See if stdout is a terminal if [ -t 1 ] && command -v tput > /dev/null; then # see if it supports colors - ncolors=$(tput colors) + ncolors=$(tput colors || echo 0) if [ -n "$ncolors" ] && [ $ncolors -ge 8 ]; then bold="$(tput bold || echo)" normal="$(tput sgr0 || echo)" @@ -40,7 +40,7 @@ if [ -t 1 ] && command -v tput > /dev/null; then fi say_warning() { - printf "%b\n" "${yellow:-}dotnet_install: Warning: $1${normal:-}" + printf "%b\n" "${yellow:-}dotnet_install: Warning: $1${normal:-}" >&3 } say_err() { @@ -135,6 +135,31 @@ get_legacy_os_name_from_platform() { return 1 } +get_legacy_os_name() { + eval $invocation + + local uname=$(uname) + if [ "$uname" = "Darwin" ]; then + echo "osx" + return 0 + elif [ -n "$runtime_id" ]; then + echo $(get_legacy_os_name_from_platform "${runtime_id%-*}" || echo "${runtime_id%-*}") + return 0 + else + if [ -e /etc/os-release ]; then + . /etc/os-release + os=$(get_legacy_os_name_from_platform "$ID${VERSION_ID:+.${VERSION_ID}}" || echo "") + if [ -n "$os" ]; then + echo "$os" + return 0 + fi + fi + fi + + say_verbose "Distribution specific OS name and version could not be detected: UName = $uname" + return 1 +} + get_linux_platform_name() { eval $invocation @@ -174,8 +199,8 @@ get_current_os_name() { echo "freebsd" return 0 elif [ "$uname" = "Linux" ]; then - local linux_platform_name - linux_platform_name="$(get_linux_platform_name)" || { echo "linux" && return 0 ; } + local linux_platform_name="" + linux_platform_name="$(get_linux_platform_name)" || true if [ "$linux_platform_name" = "rhel.6" ]; then echo $linux_platform_name @@ -183,6 +208,9 @@ get_current_os_name() { elif is_musl_based_distro; then echo "linux-musl" return 0 + elif [ "$linux_platform_name" = "linux-musl" ]; then + echo "linux-musl" + return 0 else echo "linux" return 0 @@ -193,39 +221,13 @@ get_current_os_name() { return 1 } -get_legacy_os_name() { - eval $invocation - - local uname=$(uname) - if [ "$uname" = "Darwin" ]; then - echo "osx" - return 0 - elif [ -n "$runtime_id" ]; then - echo $(get_legacy_os_name_from_platform "${runtime_id%-*}" || echo "${runtime_id%-*}") - return 0 - else - if [ -e /etc/os-release ]; then - . /etc/os-release - os=$(get_legacy_os_name_from_platform "$ID${VERSION_ID:+.${VERSION_ID}}" || echo "") - if [ -n "$os" ]; then - echo "$os" - return 0 - fi - fi - fi - - say_verbose "Distribution specific OS name and version could not be detected: UName = $uname" - return 1 -} - machine_has() { eval $invocation - hash "$1" > /dev/null 2>&1 + command -v "$1" > /dev/null 2>&1 return $? } - check_min_reqs() { local hasMinimum=false if machine_has "curl"; then @@ -296,14 +298,18 @@ get_machine_architecture() { if command -v uname > /dev/null; then CPUName=$(uname -m) case $CPUName in - armv7l) + armv*l) echo "arm" return 0 ;; - aarch64) + aarch64|arm64) echo "arm64" return 0 ;; + s390x) + echo "s390x" + return 0 + ;; esac fi @@ -318,11 +324,13 @@ get_normalized_architecture_from_architecture() { eval $invocation local architecture="$(to_lowercase "$1")" + + if [[ $architecture == \ ]]; then + echo "$(get_machine_architecture)" + return 0 + fi + case "$architecture" in - \) - echo "$(get_normalized_architecture_from_architecture "$(get_machine_architecture)")" - return 0 - ;; amd64|x64) echo "x64" return 0 @@ -335,12 +343,164 @@ get_normalized_architecture_from_architecture() { echo "arm64" return 0 ;; + s390x) + echo "s390x" + return 0 + ;; esac say_err "Architecture \`$architecture\` not supported. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues" return 1 } +# args: +# version - $1 +# channel - $2 +# architecture - $3 +get_normalized_architecture_for_specific_sdk_version() { + eval $invocation + + local is_version_support_arm64="$(is_arm64_supported "$1")" + local is_channel_support_arm64="$(is_arm64_supported "$2")" + local architecture="$3"; + local osname="$(get_current_os_name)" + + if [ "$osname" == "osx" ] && [ "$architecture" == "arm64" ] && { [ "$is_version_support_arm64" = false ] || [ "$is_channel_support_arm64" = false ]; }; then + #check if rosetta is installed + if [ "$(/usr/bin/pgrep oahd >/dev/null 2>&1;echo $?)" -eq 0 ]; then + say_verbose "Changing user architecture from '$architecture' to 'x64' because .NET SDKs prior to version 6.0 do not support arm64." + echo "x64" + return 0; + else + say_err "Architecture \`$architecture\` is not supported for .NET SDK version \`$version\`. Please install Rosetta to allow emulation of the \`$architecture\` .NET SDK on this platform" + return 1 + fi + fi + + echo "$architecture" + return 0 +} + +# args: +# version or channel - $1 +is_arm64_supported() { + #any channel or version that starts with the specified versions + case "$1" in + ( "1"* | "2"* | "3"* | "4"* | "5"*) + echo false + return 0 + esac + + echo true + return 0 +} + +# args: +# user_defined_os - $1 +get_normalized_os() { + eval $invocation + + local osname="$(to_lowercase "$1")" + if [ ! -z "$osname" ]; then + case "$osname" in + osx | freebsd | rhel.6 | linux-musl | linux) + echo "$osname" + return 0 + ;; + *) + say_err "'$user_defined_os' is not a supported value for --os option, supported values are: osx, linux, linux-musl, freebsd, rhel.6. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues." + return 1 + ;; + esac + else + osname="$(get_current_os_name)" || return 1 + fi + echo "$osname" + return 0 +} + +# args: +# quality - $1 +get_normalized_quality() { + eval $invocation + + local quality="$(to_lowercase "$1")" + if [ ! -z "$quality" ]; then + case "$quality" in + daily | signed | validated | preview) + echo "$quality" + return 0 + ;; + ga) + #ga quality is available without specifying quality, so normalizing it to empty + return 0 + ;; + *) + say_err "'$quality' is not a supported value for --quality option. Supported values are: daily, signed, validated, preview, ga. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues." + return 1 + ;; + esac + fi + return 0 +} + +# args: +# channel - $1 +get_normalized_channel() { + eval $invocation + + local channel="$(to_lowercase "$1")" + + if [[ $channel == current ]]; then + say_warning 'Value "Current" is deprecated for -Channel option. Use "STS" instead.' + fi + + if [[ $channel == release/* ]]; then + say_warning 'Using branch name with -Channel option is no longer supported with newer releases. Use -Quality option with a channel in X.Y format instead.'; + fi + + if [ ! -z "$channel" ]; then + case "$channel" in + lts) + echo "LTS" + return 0 + ;; + sts) + echo "STS" + return 0 + ;; + current) + echo "STS" + return 0 + ;; + *) + echo "$channel" + return 0 + ;; + esac + fi + + return 0 +} + +# args: +# runtime - $1 +get_normalized_product() { + eval $invocation + + local product="" + local runtime="$(to_lowercase "$1")" + if [[ "$runtime" == "dotnet" ]]; then + product="dotnet-runtime" + elif [[ "$runtime" == "aspnetcore" ]]; then + product="aspnetcore-runtime" + elif [ -z "$runtime" ]; then + product="dotnet-sdk" + fi + echo "$product" + return 0 +} + # The version text returned from the feeds is a 1-line or 2-line string: # For the SDK and the dotnet runtime (2 lines): # Line 1: # commit_hash @@ -350,7 +510,7 @@ get_normalized_architecture_from_architecture() { # args: # version_text - stdin -get_version_from_version_info() { +get_version_from_latestversion_file_content() { eval $invocation cat | tail -n 1 | sed 's/\r$//' @@ -382,39 +542,33 @@ is_dotnet_package_installed() { # azure_feed - $1 # channel - $2 # normalized_architecture - $3 -# coherent - $4 -get_latest_version_info() { +get_version_from_latestversion_file() { eval $invocation local azure_feed="$1" local channel="$2" local normalized_architecture="$3" - local coherent="$4" local version_file_url=null if [[ "$runtime" == "dotnet" ]]; then - version_file_url="$uncached_feed/Runtime/$channel/latest.version" + version_file_url="$azure_feed/Runtime/$channel/latest.version" elif [[ "$runtime" == "aspnetcore" ]]; then - version_file_url="$uncached_feed/aspnetcore/Runtime/$channel/latest.version" + version_file_url="$azure_feed/aspnetcore/Runtime/$channel/latest.version" elif [ -z "$runtime" ]; then - if [ "$coherent" = true ]; then - version_file_url="$uncached_feed/Sdk/$channel/latest.coherent.version" - else - version_file_url="$uncached_feed/Sdk/$channel/latest.version" - fi + version_file_url="$azure_feed/Sdk/$channel/latest.version" else say_err "Invalid value for \$runtime" return 1 fi - say_verbose "get_latest_version_info: latest url: $version_file_url" + say_verbose "get_version_from_latestversion_file: latest url: $version_file_url" - download "$version_file_url" - return $? + download "$version_file_url" || return $? + return 0 } # args: # json_file - $1 -parse_jsonfile_for_version() { +parse_globaljson_file_for_version() { eval $invocation local json_file="$1" @@ -423,7 +577,7 @@ parse_jsonfile_for_version() { return 1 fi - sdk_section=$(cat $json_file | awk '/"sdk"/,/}/') + sdk_section=$(cat $json_file | tr -d "\r" | awk '/"sdk"/,/}/') if [ -z "$sdk_section" ]; then say_err "Unable to parse the SDK node in \`$json_file\`" return 1 @@ -468,29 +622,19 @@ get_specific_version_from_version() { local json_file="$5" if [ -z "$json_file" ]; then - case "$version" in - latest) - local version_info - version_info="$(get_latest_version_info "$azure_feed" "$channel" "$normalized_architecture" false)" || return 1 - say_verbose "get_specific_version_from_version: version_info=$version_info" - echo "$version_info" | get_version_from_version_info - return 0 - ;; - coherent) - local version_info - version_info="$(get_latest_version_info "$azure_feed" "$channel" "$normalized_architecture" true)" || return 1 - say_verbose "get_specific_version_from_version: version_info=$version_info" - echo "$version_info" | get_version_from_version_info - return 0 - ;; - *) - echo "$version" - return 0 - ;; - esac + if [[ "$version" == "latest" ]]; then + local version_info + version_info="$(get_version_from_latestversion_file "$azure_feed" "$channel" "$normalized_architecture" false)" || return 1 + say_verbose "get_specific_version_from_version: version_info=$version_info" + echo "$version_info" | get_version_from_latestversion_file_content + return 0 + else + echo "$version" + return 0 + fi else local version_info - version_info="$(parse_jsonfile_for_version "$json_file")" || return 1 + version_info="$(parse_globaljson_file_for_version "$json_file")" || return 1 echo "$version_info" return 0 fi @@ -501,6 +645,7 @@ get_specific_version_from_version() { # channel - $2 # normalized_architecture - $3 # specific_version - $4 +# normalized_os - $5 construct_download_link() { eval $invocation @@ -509,9 +654,7 @@ construct_download_link() { local normalized_architecture="$3" local specific_version="${4//[$'\t\r\n']}" local specific_product_version="$(get_specific_product_version "$1" "$4")" - - local osname - osname="$(get_current_os_name)" || return 1 + local osname="$5" local download_link=null if [[ "$runtime" == "dotnet" ]]; then @@ -531,43 +674,133 @@ construct_download_link() { # args: # azure_feed - $1 # specific_version - $2 +# download link - $3 (optional) get_specific_product_version() { - # If we find a 'productVersion.txt' at the root of any folder, we'll use its contents + # If we find a 'productVersion.txt' at the root of any folder, we'll use its contents # to resolve the version of what's in the folder, superseding the specified version. + # if 'productVersion.txt' is missing but download link is already available, product version will be taken from download link eval $invocation local azure_feed="$1" local specific_version="${2//[$'\t\r\n']}" - local specific_product_version=$specific_version - - local download_link=null - if [[ "$runtime" == "dotnet" ]]; then - download_link="$azure_feed/Runtime/$specific_version/productVersion.txt${feed_credential}" - elif [[ "$runtime" == "aspnetcore" ]]; then - download_link="$azure_feed/aspnetcore/Runtime/$specific_version/productVersion.txt${feed_credential}" - elif [ -z "$runtime" ]; then - download_link="$azure_feed/Sdk/$specific_version/productVersion.txt${feed_credential}" - else - return 1 + local package_download_link="" + if [ $# -gt 2 ]; then + local package_download_link="$3" fi + local specific_product_version=null + + # Try to get the version number, using the productVersion.txt file located next to the installer file. + local download_links=($(get_specific_product_version_url "$azure_feed" "$specific_version" true "$package_download_link") + $(get_specific_product_version_url "$azure_feed" "$specific_version" false "$package_download_link")) + + for download_link in "${download_links[@]}" + do + say_verbose "Checking for the existence of $download_link" - if machine_has "curl" - then - specific_product_version=$(curl -s --fail "$download_link") - if [ $? -ne 0 ] + if machine_has "curl" then - specific_product_version=$specific_version - fi - elif machine_has "wget" - then - specific_product_version=$(wget -qO- "$download_link") - if [ $? -ne 0 ] + if ! specific_product_version=$(curl -s --fail "${download_link}${feed_credential}" 2>&1); then + continue + else + echo "${specific_product_version//[$'\t\r\n']}" + return 0 + fi + + elif machine_has "wget" then - specific_product_version=$specific_version + specific_product_version=$(wget -qO- "${download_link}${feed_credential}" 2>&1) + if [ $? = 0 ]; then + echo "${specific_product_version//[$'\t\r\n']}" + return 0 + fi fi + done + + # Getting the version number with productVersion.txt has failed. Try parsing the download link for a version number. + say_verbose "Failed to get the version using productVersion.txt file. Download link will be parsed instead." + specific_product_version="$(get_product_specific_version_from_download_link "$package_download_link" "$specific_version")" + echo "${specific_product_version//[$'\t\r\n']}" + return 0 +} + +# args: +# azure_feed - $1 +# specific_version - $2 +# is_flattened - $3 +# download link - $4 (optional) +get_specific_product_version_url() { + eval $invocation + + local azure_feed="$1" + local specific_version="$2" + local is_flattened="$3" + local package_download_link="" + if [ $# -gt 3 ]; then + local package_download_link="$4" + fi + + local pvFileName="productVersion.txt" + if [ "$is_flattened" = true ]; then + if [ -z "$runtime" ]; then + pvFileName="sdk-productVersion.txt" + elif [[ "$runtime" == "dotnet" ]]; then + pvFileName="runtime-productVersion.txt" + else + pvFileName="$runtime-productVersion.txt" + fi + fi + + local download_link=null + + if [ -z "$package_download_link" ]; then + if [[ "$runtime" == "dotnet" ]]; then + download_link="$azure_feed/Runtime/$specific_version/${pvFileName}" + elif [[ "$runtime" == "aspnetcore" ]]; then + download_link="$azure_feed/aspnetcore/Runtime/$specific_version/${pvFileName}" + elif [ -z "$runtime" ]; then + download_link="$azure_feed/Sdk/$specific_version/${pvFileName}" + else + return 1 + fi + else + download_link="${package_download_link%/*}/${pvFileName}" fi - specific_product_version="${specific_product_version//[$'\t\r\n']}" + say_verbose "Constructed productVersion link: $download_link" + echo "$download_link" + return 0 +} + +# args: +# download link - $1 +# specific version - $2 +get_product_specific_version_from_download_link() +{ + eval $invocation + + local download_link="$1" + local specific_version="$2" + local specific_product_version="" + + if [ -z "$download_link" ]; then + echo "$specific_version" + return 0 + fi + + #get filename + filename="${download_link##*/}" + + #product specific version follows the product name + #for filename 'dotnet-sdk-3.1.404-linux-x64.tar.gz': the product version is 3.1.404 + IFS='-' + read -ra filename_elems <<< "$filename" + count=${#filename_elems[@]} + if [[ "$count" -gt 2 ]]; then + specific_product_version="${filename_elems[2]}" + else + specific_product_version=$specific_version + fi + unset IFS; echo "$specific_product_version" return 0 } @@ -692,11 +925,84 @@ extract_dotnet_package() { find "$temp_out_path" -type f | grep -Ev "$folders_with_version_regex" | copy_files_or_dirs_from_list "$temp_out_path" "$out_path" "$override_non_versioned_files" rm -rf "$temp_out_path" + rm -f "$zip_path" && say_verbose "Temporary zip file $zip_path was removed" if [ "$failed" = true ]; then say_err "Extraction failed" return 1 fi + return 0 +} + +# args: +# remote_path - $1 +# disable_feed_credential - $2 +get_http_header() +{ + eval $invocation + local remote_path="$1" + local disable_feed_credential="$2" + + local failed=false + local response + if machine_has "curl"; then + get_http_header_curl $remote_path $disable_feed_credential || failed=true + elif machine_has "wget"; then + get_http_header_wget $remote_path $disable_feed_credential || failed=true + else + failed=true + fi + if [ "$failed" = true ]; then + say_verbose "Failed to get HTTP header: '$remote_path'." + return 1 + fi + return 0 +} + +# args: +# remote_path - $1 +# disable_feed_credential - $2 +get_http_header_curl() { + eval $invocation + local remote_path="$1" + local disable_feed_credential="$2" + + remote_path_with_credential="$remote_path" + if [ "$disable_feed_credential" = false ]; then + remote_path_with_credential+="$feed_credential" + fi + + curl_options="-I -sSL --retry 5 --retry-delay 2 --connect-timeout 15 " + curl $curl_options "$remote_path_with_credential" 2>&1 || return 1 + return 0 +} + +# args: +# remote_path - $1 +# disable_feed_credential - $2 +get_http_header_wget() { + eval $invocation + local remote_path="$1" + local disable_feed_credential="$2" + local wget_options="-q -S --spider --tries 5 " + + local wget_options_extra='' + + # Test for options that aren't supported on all wget implementations. + if [[ $(wget -h 2>&1 | grep -E 'waitretry|connect-timeout') ]]; then + wget_options_extra="--waitretry 2 --connect-timeout 15 " + else + say "wget extra options are unavailable for this environment" + fi + + remote_path_with_credential="$remote_path" + if [ "$disable_feed_credential" = false ]; then + remote_path_with_credential+="$feed_credential" + fi + + wget $wget_options $wget_options_extra "$remote_path_with_credential" 2>&1 + + return $? } # args: @@ -714,13 +1020,28 @@ download() { fi local failed=false - if machine_has "curl"; then - downloadcurl "$remote_path" "$out_path" || failed=true - elif machine_has "wget"; then - downloadwget "$remote_path" "$out_path" || failed=true - else - failed=true - fi + local attempts=0 + while [ $attempts -lt 3 ]; do + attempts=$((attempts+1)) + failed=false + if machine_has "curl"; then + downloadcurl "$remote_path" "$out_path" || failed=true + elif machine_has "wget"; then + downloadwget "$remote_path" "$out_path" || failed=true + else + say_err "Missing dependency: neither curl nor wget was found." + exit 1 + fi + + if [ "$failed" = false ] || [ $attempts -ge 3 ] || { [ ! -z $http_code ] && [ $http_code = "404" ]; }; then + break + fi + + say "Download attempt #$attempts has failed: $http_code $download_error_msg" + say "Attempt #$((attempts+1)) will start in $((attempts*10)) seconds." + sleep $((attempts*10)) + done + if [ "$failed" = true ]; then say_verbose "Download failed: $remote_path" return 1 @@ -728,84 +1049,357 @@ download() { return 0 } +# Updates global variables $http_code and $download_error_msg downloadcurl() { eval $invocation + unset http_code + unset download_error_msg local remote_path="$1" local out_path="${2:-}" - # Append feed_credential as late as possible before calling curl to avoid logging feed_credential - remote_path="${remote_path}${feed_credential}" - + # Avoid passing URI with credentials to functions: note, most of them echoing parameters of invocation in verbose output. + local remote_path_with_credential="${remote_path}${feed_credential}" local curl_options="--retry 20 --retry-delay 2 --connect-timeout 15 -sSL -f --create-dirs " - local failed=false + local curl_exit_code=0; if [ -z "$out_path" ]; then - curl $curl_options "$remote_path" || failed=true + curl $curl_options "$remote_path_with_credential" 2>&1 + curl_exit_code=$? else - curl $curl_options -o "$out_path" "$remote_path" || failed=true + curl $curl_options -o "$out_path" "$remote_path_with_credential" 2>&1 + curl_exit_code=$? fi - if [ "$failed" = true ]; then - say_verbose "Curl download failed" + + if [ $curl_exit_code -gt 0 ]; then + download_error_msg="Unable to download $remote_path." + # Check for curl timeout codes + if [[ $curl_exit_code == 7 || $curl_exit_code == 28 ]]; then + download_error_msg+=" Failed to reach the server: connection timeout." + else + local disable_feed_credential=false + local response=$(get_http_header_curl $remote_path $disable_feed_credential) + http_code=$( echo "$response" | awk '/^HTTP/{print $2}' | tail -1 ) + if [[ ! -z $http_code && $http_code != 2* ]]; then + download_error_msg+=" Returned HTTP status code: $http_code." + fi + fi + say_verbose "$download_error_msg" return 1 fi return 0 } + +# Updates global variables $http_code and $download_error_msg downloadwget() { eval $invocation + unset http_code + unset download_error_msg local remote_path="$1" local out_path="${2:-}" - # Append feed_credential as late as possible before calling wget to avoid logging feed_credential - remote_path="${remote_path}${feed_credential}" - local wget_options="--tries 20 --waitretry 2 --connect-timeout 15 " - local failed=false + local remote_path_with_credential="${remote_path}${feed_credential}" + local wget_options="--tries 20 " + + local wget_options_extra='' + local wget_result='' + + # Test for options that aren't supported on all wget implementations. + if [[ $(wget -h 2>&1 | grep -E 'waitretry|connect-timeout') ]]; then + wget_options_extra="--waitretry 2 --connect-timeout 15 " + else + say "wget extra options are unavailable for this environment" + fi + if [ -z "$out_path" ]; then - wget -q $wget_options -O - "$remote_path" || failed=true + wget -q $wget_options $wget_options_extra -O - "$remote_path_with_credential" 2>&1 + wget_result=$? else - wget $wget_options -O "$out_path" "$remote_path" || failed=true + wget $wget_options $wget_options_extra -O "$out_path" "$remote_path_with_credential" 2>&1 + wget_result=$? fi - if [ "$failed" = true ]; then - say_verbose "Wget download failed" + + if [[ $wget_result != 0 ]]; then + local disable_feed_credential=false + local response=$(get_http_header_wget $remote_path $disable_feed_credential) + http_code=$( echo "$response" | awk '/^ HTTP/{print $2}' | tail -1 ) + download_error_msg="Unable to download $remote_path." + if [[ ! -z $http_code && $http_code != 2* ]]; then + download_error_msg+=" Returned HTTP status code: $http_code." + # wget exit code 4 stands for network-issue + elif [[ $wget_result == 4 ]]; then + download_error_msg+=" Failed to reach the server: connection timeout." + fi + say_verbose "$download_error_msg" return 1 fi + return 0 } -calculate_vars() { +get_download_link_from_aka_ms() { eval $invocation - valid_legacy_download_link=true - normalized_architecture="$(get_normalized_architecture_from_architecture "$architecture")" - say_verbose "normalized_architecture=$normalized_architecture" + #quality is not supported for LTS or STS channel + #STS maps to current + if [[ ! -z "$normalized_quality" && ("$normalized_channel" == "LTS" || "$normalized_channel" == "STS") ]]; then + normalized_quality="" + say_warning "Specifying quality for STS or LTS channel is not supported, the quality will be ignored." + fi - specific_version="$(get_specific_version_from_version "$azure_feed" "$channel" "$normalized_architecture" "$version" "$json_file")" - specific_product_version="$(get_specific_product_version "$azure_feed" "$specific_version")" - say_verbose "specific_version=$specific_version" - if [ -z "$specific_version" ]; then - say_err "Could not resolve version information." + say_verbose "Retrieving primary payload URL from aka.ms for channel: '$normalized_channel', quality: '$normalized_quality', product: '$normalized_product', os: '$normalized_os', architecture: '$normalized_architecture'." + + #construct aka.ms link + aka_ms_link="https://aka.ms/dotnet" + if [ "$internal" = true ]; then + aka_ms_link="$aka_ms_link/internal" + fi + aka_ms_link="$aka_ms_link/$normalized_channel" + if [[ ! -z "$normalized_quality" ]]; then + aka_ms_link="$aka_ms_link/$normalized_quality" + fi + aka_ms_link="$aka_ms_link/$normalized_product-$normalized_os-$normalized_architecture.tar.gz" + say_verbose "Constructed aka.ms link: '$aka_ms_link'." + + #get HTTP response + #do not pass credentials as a part of the $aka_ms_link and do not apply credentials in the get_http_header function + #otherwise the redirect link would have credentials as well + #it would result in applying credentials twice to the resulting link and thus breaking it, and in echoing credentials to the output as a part of redirect link + disable_feed_credential=true + response="$(get_http_header $aka_ms_link $disable_feed_credential)" + + say_verbose "Received response: $response" + # Get results of all the redirects. + http_codes=$( echo "$response" | awk '$1 ~ /^HTTP/ {print $2}' ) + # They all need to be 301, otherwise some links are broken (except for the last, which is not a redirect but 200 or 404). + broken_redirects=$( echo "$http_codes" | sed '$d' | grep -v '301' ) + + # All HTTP codes are 301 (Moved Permanently), the redirect link exists. + if [[ -z "$broken_redirects" ]]; then + aka_ms_download_link=$( echo "$response" | awk '$1 ~ /^Location/{print $2}' | tail -1 | tr -d '\r') + + if [[ -z "$aka_ms_download_link" ]]; then + say_verbose "The aka.ms link '$aka_ms_link' is not valid: failed to get redirect location." + return 1 + fi + + say_verbose "The redirect location retrieved: '$aka_ms_download_link'." + return 0 + else + say_verbose "The aka.ms link '$aka_ms_link' is not valid: received HTTP code: $(echo "$broken_redirects" | paste -sd "," -)." + return 1 + fi +} + +get_feeds_to_use() +{ + feeds=( + "https://dotnetcli.azureedge.net/dotnet" + "https://dotnetbuilds.azureedge.net/public" + ) + + if [[ -n "$azure_feed" ]]; then + feeds=("$azure_feed") + fi + + if [[ "$no_cdn" == "true" ]]; then + feeds=( + "https://dotnetcli.blob.core.windows.net/dotnet" + "https://dotnetbuilds.blob.core.windows.net/public" + ) + + if [[ -n "$uncached_feed" ]]; then + feeds=("$uncached_feed") + fi + fi +} + +# THIS FUNCTION MAY EXIT (if the determined version is already installed). +generate_download_links() { + + download_links=() + specific_versions=() + effective_versions=() + link_types=() + + # If generate_akams_links returns false, no fallback to old links. Just terminate. + # This function may also 'exit' (if the determined version is already installed). + generate_akams_links || return + + # Check other feeds only if we haven't been able to find an aka.ms link. + if [[ "${#download_links[@]}" -lt 1 ]]; then + for feed in ${feeds[@]} + do + # generate_regular_links may also 'exit' (if the determined version is already installed). + generate_regular_links $feed || return + done + fi + + if [[ "${#download_links[@]}" -eq 0 ]]; then + say_err "Failed to resolve the exact version number." + return 1 + fi + + say_verbose "Generated ${#download_links[@]} links." + for link_index in ${!download_links[@]} + do + say_verbose "Link $link_index: ${link_types[$link_index]}, ${effective_versions[$link_index]}, ${download_links[$link_index]}" + done +} + +# THIS FUNCTION MAY EXIT (if the determined version is already installed). +generate_akams_links() { + local valid_aka_ms_link=true; + + normalized_version="$(to_lowercase "$version")" + if [[ "$normalized_version" != "latest" ]] && [ -n "$normalized_quality" ]; then + say_err "Quality and Version options are not allowed to be specified simultaneously. See https://learn.microsoft.com/dotnet/core/tools/dotnet-install-script#options for details." return 1 fi - download_link="$(construct_download_link "$azure_feed" "$channel" "$normalized_architecture" "$specific_version")" + if [[ -n "$json_file" || "$normalized_version" != "latest" ]]; then + # aka.ms links are not needed when exact version is specified via command or json file + return + fi + + get_download_link_from_aka_ms || valid_aka_ms_link=false + + if [[ "$valid_aka_ms_link" == true ]]; then + say_verbose "Retrieved primary payload URL from aka.ms link: '$aka_ms_download_link'." + say_verbose "Downloading using legacy url will not be attempted." + + download_link=$aka_ms_download_link + + #get version from the path + IFS='/' + read -ra pathElems <<< "$download_link" + count=${#pathElems[@]} + specific_version="${pathElems[count-2]}" + unset IFS; + say_verbose "Version: '$specific_version'." + + #Retrieve effective version + effective_version="$(get_specific_product_version "$azure_feed" "$specific_version" "$download_link")" + + # Add link info to arrays + download_links+=($download_link) + specific_versions+=($specific_version) + effective_versions+=($effective_version) + link_types+=("aka.ms") + + # Check if the SDK version is already installed. + if [[ "$dry_run" != true ]] && is_dotnet_package_installed "$install_root" "$asset_relative_path" "$effective_version"; then + say "$asset_name with version '$effective_version' is already installed." + exit 0 + fi + + return 0 + fi + + # if quality is specified - exit with error - there is no fallback approach + if [ ! -z "$normalized_quality" ]; then + say_err "Failed to locate the latest version in the channel '$normalized_channel' with '$normalized_quality' quality for '$normalized_product', os: '$normalized_os', architecture: '$normalized_architecture'." + say_err "Refer to: https://aka.ms/dotnet-os-lifecycle for information on .NET Core support." + return 1 + fi + say_verbose "Falling back to latest.version file approach." +} + +# THIS FUNCTION MAY EXIT (if the determined version is already installed) +# args: +# feed - $1 +generate_regular_links() { + local feed="$1" + local valid_legacy_download_link=true + + specific_version=$(get_specific_version_from_version "$feed" "$channel" "$normalized_architecture" "$version" "$json_file") || specific_version='0' + + if [[ "$specific_version" == '0' ]]; then + say_verbose "Failed to resolve the specific version number using feed '$feed'" + return + fi + + effective_version="$(get_specific_product_version "$feed" "$specific_version")" + say_verbose "specific_version=$specific_version" + + download_link="$(construct_download_link "$feed" "$channel" "$normalized_architecture" "$specific_version" "$normalized_os")" say_verbose "Constructed primary named payload URL: $download_link" - legacy_download_link="$(construct_legacy_download_link "$azure_feed" "$channel" "$normalized_architecture" "$specific_version")" || valid_legacy_download_link=false + # Add link info to arrays + download_links+=($download_link) + specific_versions+=($specific_version) + effective_versions+=($effective_version) + link_types+=("primary") + + legacy_download_link="$(construct_legacy_download_link "$feed" "$channel" "$normalized_architecture" "$specific_version")" || valid_legacy_download_link=false if [ "$valid_legacy_download_link" = true ]; then say_verbose "Constructed legacy named payload URL: $legacy_download_link" + + download_links+=($legacy_download_link) + specific_versions+=($specific_version) + effective_versions+=($effective_version) + link_types+=("legacy") else + legacy_download_link="" say_verbose "Cound not construct a legacy_download_link; omitting..." fi - install_root="$(resolve_installation_path "$install_dir")" - say_verbose "InstallRoot: $install_root" + # Check if the SDK version is already installed. + if [[ "$dry_run" != true ]] && is_dotnet_package_installed "$install_root" "$asset_relative_path" "$effective_version"; then + say "$asset_name with version '$effective_version' is already installed." + exit 0 + fi } -install_dotnet() { +print_dry_run() { + + say "Payload URLs:" + + for link_index in "${!download_links[@]}" + do + say "URL #$link_index - ${link_types[$link_index]}: ${download_links[$link_index]}" + done + + resolved_version=${specific_versions[0]} + repeatable_command="./$script_name --version "\""$resolved_version"\"" --install-dir "\""$install_root"\"" --architecture "\""$normalized_architecture"\"" --os "\""$normalized_os"\""" + + if [ ! -z "$normalized_quality" ]; then + repeatable_command+=" --quality "\""$normalized_quality"\""" + fi + + if [[ "$runtime" == "dotnet" ]]; then + repeatable_command+=" --runtime "\""dotnet"\""" + elif [[ "$runtime" == "aspnetcore" ]]; then + repeatable_command+=" --runtime "\""aspnetcore"\""" + fi + + repeatable_command+="$non_dynamic_parameters" + + if [ -n "$feed_credential" ]; then + repeatable_command+=" --feed-credential "\"""\""" + fi + + say "Repeatable invocation: $repeatable_command" +} + +calculate_vars() { eval $invocation - local download_failed=false - local asset_name='' - local asset_relative_path='' + + script_name=$(basename "$0") + normalized_architecture="$(get_normalized_architecture_from_architecture "$architecture")" + say_verbose "Normalized architecture: '$normalized_architecture'." + normalized_os="$(get_normalized_os "$user_defined_os")" + say_verbose "Normalized OS: '$normalized_os'." + normalized_quality="$(get_normalized_quality "$quality")" + say_verbose "Normalized quality: '$normalized_quality'." + normalized_channel="$(get_normalized_channel "$channel")" + say_verbose "Normalized channel: '$normalized_channel'." + normalized_product="$(get_normalized_product "$runtime")" + say_verbose "Normalized product: '$normalized_product'." + install_root="$(resolve_installation_path "$install_dir")" + say_verbose "InstallRoot: '$install_root'." + + normalized_architecture="$(get_normalized_architecture_for_specific_sdk_version "$version" "$normalized_channel" "$normalized_architecture")" if [[ "$runtime" == "dotnet" ]]; then asset_relative_path="shared/Microsoft.NETCore.App" @@ -816,53 +1410,57 @@ install_dotnet() { elif [ -z "$runtime" ]; then asset_relative_path="sdk" asset_name=".NET Core SDK" - else - say_err "Invalid value for \$runtime" - return 1 fi - # Check if the SDK version is already installed. - if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$specific_version"; then - say "$asset_name version $specific_version is already installed." - return 0 - fi + get_feeds_to_use +} + +install_dotnet() { + eval $invocation + local download_failed=false + local download_completed=false mkdir -p "$install_root" zip_path="$(mktemp "$temporary_file_template")" say_verbose "Zip path: $zip_path" - say "Downloading link: $download_link" + for link_index in "${!download_links[@]}" + do + download_link="${download_links[$link_index]}" + specific_version="${specific_versions[$link_index]}" + effective_version="${effective_versions[$link_index]}" + link_type="${link_types[$link_index]}" - # Failures are normal in the non-legacy case for ultimately legacy downloads. - # Do not output to stderr, since output to stderr is considered an error. - download "$download_link" "$zip_path" 2>&1 || download_failed=true + say "Attempting to download using $link_type link $download_link" - # if the download fails, download the legacy_download_link - if [ "$download_failed" = true ]; then - say "Cannot download: $download_link" + # The download function will set variables $http_code and $download_error_msg in case of failure. + download_failed=false + download "$download_link" "$zip_path" 2>&1 || download_failed=true - if [ "$valid_legacy_download_link" = true ]; then - download_failed=false - download_link="$legacy_download_link" - zip_path="$(mktemp "$temporary_file_template")" - say_verbose "Legacy zip path: $zip_path" - say "Downloading legacy link: $download_link" - download "$download_link" "$zip_path" 2>&1 || download_failed=true - - if [ "$download_failed" = true ]; then - say "Cannot download: $download_link" - fi + if [ "$download_failed" = true ]; then + case $http_code in + 404) + say "The resource at $link_type link '$download_link' is not available." + ;; + *) + say "Failed to download $link_type link '$download_link': $download_error_msg" + ;; + esac + rm -f "$zip_path" 2>&1 && say_verbose "Temporary zip file $zip_path was removed" + else + download_completed=true + break fi - fi + done - if [ "$download_failed" = true ]; then - say_err "Could not find/download: \`$asset_name\` with version = $specific_version" + if [[ "$download_completed" == false ]]; then + say_err "Could not find \`$asset_name\` with version = $specific_version" say_err "Refer to: https://aka.ms/dotnet-os-lifecycle for information on .NET Core support" return 1 fi say "Extracting zip from $download_link" - extract_dotnet_package "$zip_path" "$install_root" + extract_dotnet_package "$zip_path" "$install_root" || return 1 # Check if the SDK version is installed; if not, fail the installation. # if the version contains "RTM" or "servicing"; check if a 'release-type' SDK version is installed. @@ -873,17 +1471,21 @@ install_dotnet() { unset IFS; say_verbose "Checking installation: version = $release_version" if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$release_version"; then + say "Installed version is $effective_version" return 0 fi fi # Check if the standard SDK version is installed. - say_verbose "Checking installation: version = $specific_product_version" - if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$specific_product_version"; then + say_verbose "Checking installation: version = $effective_version" + if is_dotnet_package_installed "$install_root" "$asset_relative_path" "$effective_version"; then + say "Installed version is $effective_version" return 0 fi - say_err "\`$asset_name\` with version = $specific_product_version failed to install with an unknown error." + # Version verification failed. More likely something is wrong either with the downloaded content or with the verification algorithm. + say_err "Failed to verify the version of installed \`$asset_name\`.\nInstallation source: $download_link.\nInstallation location: $install_root.\nReport the bug at https://github.com/dotnet/install-scripts/issues." + say_err "\`$asset_name\` with version = $effective_version failed to install with an error." return 1 } @@ -901,14 +1503,17 @@ architecture="" dry_run=false no_path=false no_cdn=false -azure_feed="https://dotnetcli.azureedge.net/dotnet" -uncached_feed="https://dotnetcli.blob.core.windows.net/dotnet" +azure_feed="" +uncached_feed="" feed_credential="" verbose=false runtime="" runtime_id="" +quality="" +internal=false override_non_versioned_files=true non_dynamic_parameters="" +user_defined_os="" while [ $# -ne 0 ] do @@ -922,6 +1527,14 @@ do shift version="$1" ;; + -q|--quality|-[Qq]uality) + shift + quality="$1" + ;; + --internal|-[Ii]nternal) + internal=true + non_dynamic_parameters+=" $name" + ;; -i|--install-dir|-[Ii]nstall[Dd]ir) shift install_dir="$1" @@ -930,6 +1543,10 @@ do shift architecture="$1" ;; + --os|-[Oo][SS]) + shift + user_defined_os="$1" + ;; --shared-runtime|-[Ss]hared[Rr]untime) say_warning "The --shared-runtime flag is obsolete and may be removed in a future version of this script. The recommended usage is to specify '--runtime dotnet'." if [ -z "$runtime" ]; then @@ -975,12 +1592,15 @@ do --feed-credential|-[Ff]eed[Cc]redential) shift feed_credential="$1" - non_dynamic_parameters+=" $name "\""$1"\""" + #feed_credential should start with "?", for it to be added to the end of the link. + #adding "?" at the beginning of the feed_credential if needed. + [[ -z "$(echo $feed_credential)" ]] || [[ $feed_credential == \?* ]] || feed_credential="?$feed_credential" ;; --runtime-id|-[Rr]untime[Ii]d) shift runtime_id="$1" non_dynamic_parameters+=" $name "\""$1"\""" + say_warning "Use of --runtime-id is obsolete and should be limited to the versions below 2.1. To override architecture, use --architecture option instead. To override OS, use --os option instead." ;; --jsonfile|-[Jj][Ss]on[Ff]ile) shift @@ -1002,26 +1622,41 @@ do echo " -c,--channel Download from the channel specified, Defaults to \`$channel\`." echo " -Channel" echo " Possible values:" - echo " - Current - most current release" - echo " - LTS - most current supported release" + echo " - STS - the most recent Standard Term Support release" + echo " - LTS - the most recent Long Term Support release" echo " - 2-part version in a format A.B - represents a specific release" echo " examples: 2.0; 1.0" - echo " - Branch name" - echo " examples: release/2.0.0; Master" - echo " Note: The version parameter overrides the channel parameter." + echo " - 3-part version in a format A.B.Cxx - represents a specific SDK release" + echo " examples: 5.0.1xx, 5.0.2xx." + echo " Supported since 5.0 release" + echo " Warning: Value 'Current' is deprecated for the Channel parameter. Use 'STS' instead." + echo " Note: The version parameter overrides the channel parameter when any version other than 'latest' is used." echo " -v,--version Use specific VERSION, Defaults to \`$version\`." echo " -Version" echo " Possible values:" - echo " - latest - most latest build on specific channel" - echo " - coherent - most latest coherent build on specific channel" - echo " coherent applies only to SDK downloads" + echo " - latest - the latest build on specific channel" echo " - 3-part version in a format A.B.C - represents specific version of build" echo " examples: 2.0.0-preview2-006120; 1.1.0" + echo " -q,--quality Download the latest build of specified quality in the channel." + echo " -Quality" + echo " The possible values are: daily, signed, validated, preview, GA." + echo " Works only in combination with channel. Not applicable for STS and LTS channels and will be ignored if those channels are used." + echo " For SDK use channel in A.B.Cxx format. Using quality for SDK together with channel in A.B format is not supported." + echo " Supported since 5.0 release." + echo " Note: The version parameter overrides the channel parameter when any version other than 'latest' is used, and therefore overrides the quality." + echo " --internal,-Internal Download internal builds. Requires providing credentials via --feed-credential parameter." + echo " --feed-credential Token to access Azure feed. Used as a query string to append to the Azure feed." + echo " -FeedCredential This parameter typically is not specified." echo " -i,--install-dir Install under specified location (see Install Location below)" echo " -InstallDir" echo " --architecture Architecture of dotnet binaries to be installed, Defaults to \`$architecture\`." echo " --arch,-Architecture,-Arch" - echo " Possible values: x64, arm, and arm64" + echo " Possible values: x64, arm, arm64 and s390x" + echo " --os Specifies operating system to be used when selecting the installer." + echo " Overrides the OS determination approach used by the script. Supported values: osx, linux, linux-musl, freebsd, rhel.6." + echo " In case any other value is provided, the platform will be determined by the script based on machine configuration." + echo " Not supported for legacy links. Use --runtime-id to specify platform for legacy links." + echo " Refer to: https://aka.ms/dotnet-os-lifecycle for more information." echo " --runtime Installs a shared runtime only, without the SDK." echo " -Runtime" echo " Possible values:" @@ -1030,23 +1665,19 @@ do echo " --dry-run,-DryRun Do not perform installation. Display download link." echo " --no-path, -NoPath Do not set PATH for the current process." echo " --verbose,-Verbose Display diagnostics information." - echo " --azure-feed,-AzureFeed Azure feed location. Defaults to $azure_feed, This parameter typically is not changed by the user." - echo " --uncached-feed,-UncachedFeed Uncached feed location. This parameter typically is not changed by the user." - echo " --feed-credential,-FeedCredential Azure feed shared access token. This parameter typically is not specified." + echo " --azure-feed,-AzureFeed For internal use only." + echo " Allows using a different storage to download SDK archives from." + echo " This parameter is only used if --no-cdn is false." + echo " --uncached-feed,-UncachedFeed For internal use only." + echo " Allows using a different storage to download SDK archives from." + echo " This parameter is only used if --no-cdn is true." echo " --skip-non-versioned-files Skips non-versioned files if they already exist, such as the dotnet executable." echo " -SkipNonVersionedFiles" echo " --no-cdn,-NoCdn Disable downloading from the Azure CDN, and use the uncached feed directly." echo " --jsonfile Determines the SDK version from a user specified global.json file." echo " Note: global.json must have a value for 'SDK:Version'" - echo " --runtime-id Installs the .NET Tools for the given platform (use linux-x64 for portable linux)." - echo " -RuntimeId" echo " -?,--?,-h,--help,-Help Shows this help message" echo "" - echo "Obsolete parameters:" - echo " --shared-runtime The recommended alternative is '--runtime dotnet'." - echo " This parameter is obsolete and may be removed in a future version of this script." - echo " Installs just the shared runtime bits, not the entire SDK." - echo "" echo "Install Location:" echo " Location is chosen in following order:" echo " - --install-dir option" @@ -1063,33 +1694,28 @@ do shift done -if [ "$no_cdn" = true ]; then - azure_feed="$uncached_feed" -fi - say "Note that the intended use of this script is for Continuous Integration (CI) scenarios, where:" say "- The SDK needs to be installed without user interaction and without admin rights." say "- The SDK installation doesn't need to persist across multiple CI runs." say "To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer.\n" +if [ "$internal" = true ] && [ -z "$(echo $feed_credential)" ]; then + message="Provide credentials via --feed-credential parameter." + if [ "$dry_run" = true ]; then + say_warning "$message" + else + say_err "$message" + exit 1 + fi +fi + check_min_reqs calculate_vars -script_name=$(basename "$0") +# generate_regular_links call below will 'exit' if the determined version is already installed. +generate_download_links -if [ "$dry_run" = true ]; then - say "Payload URLs:" - say "Primary named payload URL: $download_link" - if [ "$valid_legacy_download_link" = true ]; then - say "Legacy named payload URL: $legacy_download_link" - fi - repeatable_command="./$script_name --version "\""$specific_version"\"" --install-dir "\""$install_root"\"" --architecture "\""$normalized_architecture"\""" - if [[ "$runtime" == "dotnet" ]]; then - repeatable_command+=" --runtime "\""dotnet"\""" - elif [[ "$runtime" == "aspnetcore" ]]; then - repeatable_command+=" --runtime "\""aspnetcore"\""" - fi - repeatable_command+="$non_dynamic_parameters" - say "Repeatable invocation: $repeatable_command" +if [[ "$dry_run" = true ]]; then + print_dry_run exit 0 fi @@ -1104,5 +1730,5 @@ else fi say "Note that the script does not resolve dependencies during installation." -say "To check the list of dependencies, go to https://docs.microsoft.com/dotnet/core/install, select your operating system and check the \"Dependencies\" section." +say "To check the list of dependencies, go to https://learn.microsoft.com/dotnet/core/install, select your operating system and check the \"Dependencies\" section." say "Installation finished successfully." From f0ede85f359b762ba8633531669da446bb1cf512 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 27 Feb 2023 22:22:53 +0100 Subject: [PATCH 088/157] Skip build when testing on CI --- appveyor.yml | 1 + test.cmd | 5 +++-- test.sh | 4 +++- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/appveyor.yml b/appveyor.yml index 24f73d208..31b274f02 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -6,6 +6,7 @@ image: environment: DOTNET_CLI_TELEMETRY_OPTOUT: true DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true + SKIP_TEST_BUILD: true for: - matrix: diff --git a/test.cmd b/test.cmd index c4f74dc2d..e3d837481 100644 --- a/test.cmd +++ b/test.cmd @@ -5,8 +5,9 @@ popd & exit /b %ERRORLEVEL% :main setlocal -call build ^ - && call :clean ^ +if not defined SKIP_TEST_BUILD set SKIP_TEST_BUILD=false +if %SKIP_TEST_BUILD%==false call build || exit /b 1 +call :clean ^ && call :test net7.0 Debug ^ && call :test net7.0 Release ^ && call :test net6.0 Debug ^ diff --git a/test.sh b/test.sh index 90d26eff9..d4f82d358 100755 --- a/test.sh +++ b/test.sh @@ -1,7 +1,9 @@ #!/usr/bin/env bash set -e cd "$(dirname "$0")" -./build.sh $c +if [[ "${SKIP_TEST_BUILD:=false}" == "false" ]]; then + ./build.sh $c +fi if [[ -d "MoreLinq.Test/TestResults" ]]; then rm -rf MoreLinq.Test/TestResults fi From f095ed29be744db1451183a9fa74dee4db70d602 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 14 Mar 2023 18:45:34 +0100 Subject: [PATCH 089/157] Pin macOS image used for CI build --- appveyor.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/appveyor.yml b/appveyor.yml index 31b274f02..22f808e6b 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -2,7 +2,7 @@ version: '{build}' image: - Visual Studio 2022 - Ubuntu1604 -- macos +- macos-bigsur environment: DOTNET_CLI_TELEMETRY_OPTOUT: true DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true @@ -38,7 +38,7 @@ for: - matrix: only: - - image: macos + - image: macos-bigsur environment: IMAGE_NAME: macos skip_commits: From e8383ebad0d3e9d372ecfaeab1b76a5719959f17 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Wed, 15 Mar 2023 00:17:35 +0100 Subject: [PATCH 090/157] Fix duplicate report option during CI build [ci skip] --- appveyor.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/appveyor.yml b/appveyor.yml index 22f808e6b..1a8636fe8 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -94,7 +94,7 @@ after_build: test_script: - cmd: test.cmd - sh: ./test.sh -- ps: dotnet reportgenerator -reports:MoreLinq.Test/TestResults/coverage-*.opencover.xml -targetdir:tmp/cover -tag:(git show -q --pretty=%H) +- ps: dotnet reportgenerator '-reports:MoreLinq.Test/TestResults/coverage-*.opencover.xml' -targetdir:tmp/cover -tag:(git show -q --pretty=%H) - ps: | cd tmp/cover tar -cz -f "../../coverage-report-${env:IMAGE_NAME}.tar.gz" * From 190263e4fb3b765aac1ba6f64fc780e82956db58 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Wed, 15 Mar 2023 00:16:49 +0100 Subject: [PATCH 091/157] Prepare for 4.0 --- MoreLinq/MoreLinq.csproj | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index d2d6b1c9d..443538f69 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -118,7 +118,7 @@ $([System.Text.RegularExpressions.Regex]::Replace($(Copyright), `\s+`, ` `).Trim()) MoreLINQ en-US - 3.4.1 + 4.0.0 MoreLINQ Developers. net462;netstandard1.0;netstandard2.0;netstandard2.1;net6.0 portable @@ -135,7 +135,7 @@ ..\dist README.md true - 3.3.1 + 3.4.1 true true true From d784050fef54ea15be29e8feff8b2ac2bff39392 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 16 Mar 2023 08:15:24 +0100 Subject: [PATCH 092/157] Set .NET Standard 2.0 as the baseline target --- MoreLinq.Test/MoreLinq.Test.csproj | 18 +- MoreLinq/AssemblyInfo.cs | 2 - MoreLinq/CompatibilitySuppressions.xml | 126 +--- MoreLinq/Experimental/Await.cs | 3 - MoreLinq/GroupAdjacent.cs | 2 - MoreLinq/MoreLinq.csproj | 24 +- .../PublicAPI/net462/PublicAPI.Shipped.txt | 678 ------------------ .../PublicAPI/net462/PublicAPI.Unshipped.txt | 1 - .../netstandard1.0/PublicAPI.Shipped.txt | 647 ----------------- .../netstandard1.0/PublicAPI.Unshipped.txt | 1 - MoreLinq/SequenceException.cs | 6 - MoreLinq/Trace.cs | 6 +- test.cmd | 8 +- test.sh | 2 +- 14 files changed, 14 insertions(+), 1510 deletions(-) delete mode 100644 MoreLinq/PublicAPI/net462/PublicAPI.Shipped.txt delete mode 100644 MoreLinq/PublicAPI/net462/PublicAPI.Unshipped.txt delete mode 100644 MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Shipped.txt delete mode 100644 MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Unshipped.txt diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index 32d7ac7b7..97e4d7bc2 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -2,10 +2,10 @@ MoreLinq.Test - net7.0;net6.0;net462 + net7.0;net6.0;net471 portable MoreLinq.Test - Exe + Exe true false @@ -46,12 +46,12 @@ - + - + @@ -63,16 +63,6 @@ - - - - - - - - - - diff --git a/MoreLinq/AssemblyInfo.cs b/MoreLinq/AssemblyInfo.cs index b41c26d8d..dc1590dbc 100644 --- a/MoreLinq/AssemblyInfo.cs +++ b/MoreLinq/AssemblyInfo.cs @@ -36,10 +36,8 @@ // CLS compliance and COM visibility [assembly: CLSCompliant(true)] -#if !NO_COM [assembly: System.Runtime.InteropServices.ComVisible(false)] // ID of the typelib if this project is exposed to COM. [assembly: System.Runtime.InteropServices.Guid("fc632c9d-390e-4902-8c1c-3e57b08c1d38")] -#endif diff --git a/MoreLinq/CompatibilitySuppressions.xml b/MoreLinq/CompatibilitySuppressions.xml index 75886d3d6..1d7bf3d3e 100644 --- a/MoreLinq/CompatibilitySuppressions.xml +++ b/MoreLinq/CompatibilitySuppressions.xml @@ -2,129 +2,7 @@ - CP0001 - T:MoreLinq.Experimental.AwaitQueryOptions - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0001 - T:MoreLinq.Experimental.IAwaitQuery`1 - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0001 - T:MoreLinq.Extensions.ToDataTableExtension - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered``1(MoreLinq.Experimental.IAwaitQuery{``0}) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.Experimental.ExperimentalEnumerable.AsSequential``1(MoreLinq.Experimental.IAwaitQuery{``0}) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered``1(MoreLinq.Experimental.IAwaitQuery{``0}) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.Experimental.ExperimentalEnumerable.Await``1(System.Collections.Generic.IEnumerable{System.Threading.Tasks.Task{``0}}) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.Experimental.ExperimentalEnumerable.Await``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.Task{``1}}) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion``3(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.Task{``1}},System.Func{``0,System.Threading.Tasks.Task{``1},``2}) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Int32) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Boolean) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.Experimental.ExperimentalEnumerable.Scheduler``1(MoreLinq.Experimental.IAwaitQuery{``0},System.Threading.Tasks.TaskScheduler) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency``1(MoreLinq.Experimental.IAwaitQuery{``0}) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.ToDataTable``1(System.Collections.Generic.IEnumerable{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[]) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.ToDataTable``1(System.Collections.Generic.IEnumerable{``0}) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1,System.Linq.Expressions.Expression{System.Func{``0,System.Object}}[]) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.ToDataTable``2(System.Collections.Generic.IEnumerable{``0},``1) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.SequenceException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) - lib/net451/MoreLinq.dll - lib/netstandard1.0/MoreLinq.dll - true + PKV006 + .NETStandard,Version=v1.0 diff --git a/MoreLinq/Experimental/Await.cs b/MoreLinq/Experimental/Await.cs index 0a75a91ab..aa6e0a15f 100644 --- a/MoreLinq/Experimental/Await.cs +++ b/MoreLinq/Experimental/Await.cs @@ -15,8 +15,6 @@ // limitations under the License. #endregion -#if !NO_ASYNC - namespace MoreLinq.Experimental { using System; @@ -789,4 +787,3 @@ public void Exit() => } } -#endif // !NO_ASYNC diff --git a/MoreLinq/GroupAdjacent.cs b/MoreLinq/GroupAdjacent.cs index 4dbd0243f..a79e58499 100644 --- a/MoreLinq/GroupAdjacent.cs +++ b/MoreLinq/GroupAdjacent.cs @@ -304,9 +304,7 @@ public static Grouping Create(TKey key, IEnumera new(key, members); } -#if !NO_SERIALIZATION_ATTRIBUTES [Serializable] -#endif sealed class Grouping : IGrouping { readonly IEnumerable _members; diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 443538f69..4397916e4 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -120,7 +120,7 @@ en-US 4.0.0 MoreLINQ Developers. - net462;netstandard1.0;netstandard2.0;netstandard2.1;net6.0 + netstandard2.0;netstandard2.1;net6.0 portable true MoreLinq @@ -190,34 +190,14 @@ - - - - - - - $(DefineConstants);MORELINQ - + $(DefineConstants);NO_ASYNC_STREAMS;NO_BUFFERS - - $(DefineConstants);NO_ASYNC_STREAMS;NO_BUFFERS;NO_SERIALIZATION_ATTRIBUTES;NO_EXCEPTION_SERIALIZATION;NO_TRACING;NO_COM;NO_ASYNC - - - - - - - - - - - diff --git a/MoreLinq/PublicAPI/net462/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net462/PublicAPI.Shipped.txt deleted file mode 100644 index 1f9122f06..000000000 --- a/MoreLinq/PublicAPI/net462/PublicAPI.Shipped.txt +++ /dev/null @@ -1,678 +0,0 @@ -#nullable enable -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 -MoreLinq.Experimental.IAwaitQuery.Options.get -> MoreLinq.Experimental.AwaitQueryOptions! -MoreLinq.Experimental.IAwaitQuery.WithOptions(MoreLinq.Experimental.AwaitQueryOptions! options) -> MoreLinq.Experimental.IAwaitQuery! -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.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.MinByExtension -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 -MoreLinq.IExtremaEnumerable.Take(int count) -> System.Collections.Generic.IEnumerable! -MoreLinq.IExtremaEnumerable.TakeLast(int count) -> System.Collections.Generic.IEnumerable! -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) -> void -MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void -MoreLinq.SequenceException.SequenceException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential(this MoreLinq.Experimental.IAwaitQuery! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable!>! source) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator, System.Func!, TResult>! resultSelector) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency(this MoreLinq.Experimental.IAwaitQuery! source, int value) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.Memoize(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder(this MoreLinq.Experimental.IAwaitQuery! source, bool value) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.Scheduler(this MoreLinq.Experimental.IAwaitQuery! source, System.Threading.Tasks.TaskScheduler! value) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many) -> (TCardinality Cardinality, T? Value) -static MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Extensions.AcquireExtension.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate -static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource -static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int -static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void -static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool -static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SkipUntilExtension.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SliceExtension.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool -static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TakeUntilExtension.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! -static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.WindowRightExtension.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate -static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource -static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int -static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void -static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool -static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool -static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Unfold(TState state, System.Func! generator, System.Func! predicate, System.Func! stateSelector, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/net462/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net462/PublicAPI.Unshipped.txt deleted file mode 100644 index 7dc5c5811..000000000 --- a/MoreLinq/PublicAPI/net462/PublicAPI.Unshipped.txt +++ /dev/null @@ -1 +0,0 @@ -#nullable enable diff --git a/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Shipped.txt deleted file mode 100644 index f6d66a9be..000000000 --- a/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Shipped.txt +++ /dev/null @@ -1,647 +0,0 @@ -#nullable enable -MoreLinq.Experimental.ExperimentalEnumerable -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.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.MinByExtension -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.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 -MoreLinq.IExtremaEnumerable.Take(int count) -> System.Collections.Generic.IEnumerable! -MoreLinq.IExtremaEnumerable.TakeLast(int count) -> System.Collections.Generic.IEnumerable! -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) -> void -MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Memoize(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many) -> (TCardinality Cardinality, T? Value) -static MoreLinq.Extensions.AcquireExtension.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate -static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource -static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int -static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void -static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool -static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SkipUntilExtension.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SliceExtension.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool -static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TakeUntilExtension.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! -static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.WindowRightExtension.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate -static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource -static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int -static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void -static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool -static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool -static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Unfold(TState state, System.Func! generator, System.Func! predicate, System.Func! stateSelector, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Unshipped.txt deleted file mode 100644 index 7dc5c5811..000000000 --- a/MoreLinq/PublicAPI/netstandard1.0/PublicAPI.Unshipped.txt +++ /dev/null @@ -1 +0,0 @@ -#nullable enable diff --git a/MoreLinq/SequenceException.cs b/MoreLinq/SequenceException.cs index 8b9a3c930..c2226587b 100644 --- a/MoreLinq/SequenceException.cs +++ b/MoreLinq/SequenceException.cs @@ -18,17 +18,13 @@ namespace MoreLinq { using System; -#if !NO_EXCEPTION_SERIALIZATION using System.Runtime.Serialization; -#endif /// /// The exception that is thrown for a sequence that fails a condition. /// -#if !NO_EXCEPTION_SERIALIZATION [Serializable] -#endif public class SequenceException : Exception { const string DefaultMessage = "Error in sequence."; @@ -60,7 +56,6 @@ public SequenceException(string? message) : public SequenceException(string? message, Exception? innerException) : base(string.IsNullOrEmpty(message) ? DefaultMessage : message, innerException) { } -#if !NO_EXCEPTION_SERIALIZATION /// /// Initializes a new instance of the class /// with serialized data. @@ -70,6 +65,5 @@ public SequenceException(string? message, Exception? innerException) : protected SequenceException(SerializationInfo info, StreamingContext context) : base(info, context) { } -#endif } } diff --git a/MoreLinq/Trace.cs b/MoreLinq/Trace.cs index e47a24227..b8d5171a3 100644 --- a/MoreLinq/Trace.cs +++ b/MoreLinq/Trace.cs @@ -91,11 +91,7 @@ public static IEnumerable Trace(this IEnumerable sour static IEnumerable TraceImpl(IEnumerable source, Func formatter) { - return source -#if !NO_TRACING - .Pipe(x => System.Diagnostics.Trace.WriteLine(formatter(x))) -#endif - ; + return source.Pipe(x => System.Diagnostics.Trace.WriteLine(formatter(x))); } } } diff --git a/test.cmd b/test.cmd index e3d837481..1cc6d54be 100644 --- a/test.cmd +++ b/test.cmd @@ -12,8 +12,8 @@ call :clean ^ && call :test net7.0 Release ^ && call :test net6.0 Debug ^ && call :test net6.0 Release ^ - && call :test net462 Debug ^ - && call :test net462 Release ^ + && call :test net471 Debug ^ + && call :test net471 Release ^ && call :report-cover exit /b %ERRORLEVEL% @@ -28,8 +28,8 @@ exit /b %ERRORLEVEL% setlocal cd MoreLinq.Test echo Testing %1 (%2)... -if %1==net462 ( - bin\%2\net462\MoreLinq.Test.exe +if %1==net471 ( + bin\%2\net471\MoreLinq.Test.exe exit /b %ERRORLEVEL% ) dotnet test --no-build -f %1 -c %2 --settings coverlet.runsettings || exit /b 1 diff --git a/test.sh b/test.sh index d4f82d358..2548482d1 100755 --- a/test.sh +++ b/test.sh @@ -28,6 +28,6 @@ if [[ -z `which mono 2>/dev/null` ]]; then echo>&2 against the Mono runtime will be skipped. else for c in $configs; do - mono MoreLinq.Test/bin/$c/net462/MoreLinq.Test.exe + mono MoreLinq.Test/bin/$c/net471/MoreLinq.Test.exe done fi From 034ba56bd6e459bb7dde418eea6d921adaa557d1 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 1 Apr 2023 14:28:42 +0200 Subject: [PATCH 093/157] Fix "Unfold" bug so iterations are repeatable --- MoreLinq.Test/UnfoldTest.cs | 13 +++++++++++++ MoreLinq/Unfold.cs | 4 ++-- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/MoreLinq.Test/UnfoldTest.cs b/MoreLinq.Test/UnfoldTest.cs index 0f5a581cb..ef2a3ee1b 100644 --- a/MoreLinq.Test/UnfoldTest.cs +++ b/MoreLinq.Test/UnfoldTest.cs @@ -81,5 +81,18 @@ public void UnfoldEmptySequence() e => e.Result); Assert.That(result, Is.Empty); } + + [Test(Description = "https://github.com/morelinq/MoreLINQ/issues/990")] + public void UnfoldReiterationsReturnsSameResult() + { + var xs = MoreEnumerable.Unfold(1, n => (Result: n, Next: n + 1), + _ => true, + n => n.Next, + n => n.Result) + .Take(5); + + xs.AssertSequenceEqual(1, 2, 3, 4, 5); + xs.AssertSequenceEqual(1, 2, 3, 4, 5); + } } } diff --git a/MoreLinq/Unfold.cs b/MoreLinq/Unfold.cs index c61ef9745..d6f5b8738 100644 --- a/MoreLinq/Unfold.cs +++ b/MoreLinq/Unfold.cs @@ -61,9 +61,9 @@ public static IEnumerable Unfold( if (stateSelector == null) throw new ArgumentNullException(nameof(stateSelector)); if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return _(); IEnumerable _() + return _(state); IEnumerable _(TState initialState) { - while (true) + for (var state = initialState; ;) { var step = generator(state); From 852fb1c66714e95863992d41f77ca82f687b90ee Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 3 Apr 2023 00:55:52 +0200 Subject: [PATCH 094/157] Use docopt.net to parse extensions generator CLI args --- .../MoreLinq.ExtensionsGenerator.csproj | 1 + bld/ExtensionsGenerator/Program.cs | 97 ++++++++----------- 2 files changed, 41 insertions(+), 57 deletions(-) diff --git a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj index faf971cfd..9e19b8bfb 100644 --- a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj +++ b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj @@ -5,6 +5,7 @@ false + diff --git a/bld/ExtensionsGenerator/Program.cs b/bld/ExtensionsGenerator/Program.cs index d275c3272..f9cc083c2 100644 --- a/bld/ExtensionsGenerator/Program.cs +++ b/bld/ExtensionsGenerator/Program.cs @@ -24,6 +24,7 @@ using System.Linq; using System.Reflection; using System.Text.RegularExpressions; +using DocoptNet; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; @@ -35,8 +36,19 @@ try #pragma warning restore CA1852 // Seal internal types { - Run(args); - return 0; + var exitCode = + ProgramArguments.CreateParser() + .Parse(args) + .Match(args => { Run(args); return 0; }, _ => 1); + + if (exitCode != 0) + { + Console.Error.WriteLine("Invalid argument or usage!"); + Console.Error.WriteLine(); + Console.Error.WriteLine(ProgramArguments.Help); + } + + return exitCode; } #pragma warning disable CA1031 // Do not catch general exception types catch (Exception e) @@ -46,54 +58,9 @@ return 0xbad; } -static void Run(IEnumerable args) +static void Run(ProgramArguments args) { - var dir = Directory.GetCurrentDirectory(); - - string? includePattern = null; - string? excludePattern = null; - var debug = false; - var usings = new List(); - var noClassLead = false; - - using (var arg = args.GetEnumerator()) - { - while (arg.MoveNext()) - { - switch (arg.Current) - { - case "-i": - case "--include": - includePattern = Read(arg, MissingArgValue); - break; - case "-x": - case "--exclude": - excludePattern = Read(arg, MissingArgValue); - break; - case "-u": - case "--using": - usings.Add(Read(arg, MissingArgValue)); - break; - case "--no-class-lead": - noClassLead = true; - break; - case "-d": - case "--debug": - debug = true; - break; - case "": - continue; - default: - dir = arg.Current[0] != '-' - ? arg.Current - : throw new Exception("Invalid argument: " + arg.Current); - break; - } - } - - static Exception MissingArgValue() => - new InvalidOperationException("Missing argument value."); - } + var dir = args.ArgDir ?? Directory.GetCurrentDirectory(); static Func PredicateFromPattern(string? pattern, bool @default) => @@ -101,8 +68,8 @@ static Func ? delegate { return @default; } : new Func(new Regex(pattern).IsMatch); - var includePredicate = PredicateFromPattern(includePattern, true); - var excludePredicate = PredicateFromPattern(excludePattern, false); + var includePredicate = PredicateFromPattern(args.OptInclude, true); + var excludePredicate = PredicateFromPattern(args.OptExclude, false); var thisAssemblyName = typeof(TypeKey).GetTypeInfo().Assembly.GetName(); @@ -198,7 +165,7 @@ from e in ms.Select((m, i) => (SourceOrder: i + 1, Method: m)) q = q.ToArray(); - if (debug) + if (args.OptDebug) { var ms = // @@ -252,7 +219,7 @@ into e }; var imports = - from ns in baseImports.Concat(usings) + from ns in baseImports.Concat(args.OptUsing) select indent + $"using {ns};"; var classes = @@ -290,7 +257,7 @@ select Argument(IdentifierName(p.Identifier)), .WithSemicolonToken(ParseToken(";").WithTrailingTrivia(LineFeed)) } into m - let classLead = !noClassLead + let classLead = !args.OptNoClassLead ? $$""" /// {{m.Name}} extension. @@ -373,9 +340,6 @@ select Walk(te.Type))), }; } -static T Read(IEnumerator e, Func errorFactory) => - e.MoveNext() ? e.Current : throw errorFactory(); - // // Logical type nodes designed to be structurally sortable based on: // @@ -478,3 +442,22 @@ protected override int CompareParameters(TypeKey other) return base.CompareParameters(other); } } + +[DocoptArguments(HelpConstName = nameof(HelpText))] +sealed partial class ProgramArguments +{ + const string HelpText = """ + Usage: + #BIN# [options] [-u NAMESPACE]... [DIR] + + Options: + -i, --include REGEX Include files matching pattern. + -x, --exclude REGEX Exclude files matching pattern. + -u, --using NAMESPACE Additional using imports to add. + --no-class-lead Skip generating class lead. + -d, --debug Produce output for debugging. + """; + + public static string Help => + HelpText.Replace("#BIN#", Path.GetFileName(Environment.ProcessPath), StringComparison.Ordinal); +} From ac57083bc83544b8beffb1403dc9763a0a171c75 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 18 Jun 2023 15:11:19 +0200 Subject: [PATCH 095/157] Mark test struct read-only --- MoreLinq.Test/ToDataTableTest.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs index f9cbe83ac..ae053830c 100644 --- a/MoreLinq.Test/ToDataTableTest.cs +++ b/MoreLinq.Test/ToDataTableTest.cs @@ -181,7 +181,7 @@ public void ToDataTableWithSchema() Assert.That(rows.Select(r => r["Value"]).ToArray(), Is.EqualTo(vars.Select(e => e.Value).ToArray())); } - struct Point + readonly struct Point { #pragma warning disable CA1805 // Do not initialize unnecessarily (avoids CS0649) From bf8e270d7b9135d3563e89666d6fca26940c35fb Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 18 Jun 2023 16:27:44 +0200 Subject: [PATCH 096/157] Remove temporary allocation in query --- MoreLinq/ToDataTable.cs | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/MoreLinq/ToDataTable.cs b/MoreLinq/ToDataTable.cs index 491ec8ca6..249488619 100644 --- a/MoreLinq/ToDataTable.cs +++ b/MoreLinq/ToDataTable.cs @@ -190,16 +190,16 @@ static MemberInfo[] BuildOrBindSchema(DataTable table, MemberInfo[] members) var columns = table.Columns; var schemas = from m in members - let type = m.MemberType == MemberTypes.Property - ? ((PropertyInfo)m).PropertyType - : ((FieldInfo)m).FieldType select new { Member = m, - Type = type.IsGenericType - && typeof(Nullable<>) == type.GetGenericTypeDefinition() - ? type.GetGenericArguments()[0] - : type, + Type = (m.MemberType == MemberTypes.Property + ? ((PropertyInfo)m).PropertyType + : ((FieldInfo)m).FieldType) switch + { + var type when Nullable.GetUnderlyingType(type) is { } t => t, + var type => type, + }, Column = columns[m.Name], }; From 8db4bef22ce0ba465e980d9e381d84f99aae31db Mon Sep 17 00:00:00 2001 From: Pawel Flajszer <45766938+pflajszer@users.noreply.github.com> Date: Sat, 24 Jun 2023 11:17:40 +0200 Subject: [PATCH 097/157] Remove obsolete "Concat" method This is a squashed merge of PR #1002 that closes #993. --- MoreLinq/Append.cs | 13 --------- MoreLinq/CompatibilitySuppressions.xml | 28 +++++++++++++++++++ .../PublicAPI/net6.0/PublicAPI.Unshipped.txt | 1 + .../netstandard2.0/PublicAPI.Unshipped.txt | 1 + .../netstandard2.1/PublicAPI.Unshipped.txt | 1 + README.md | 7 +++-- 6 files changed, 36 insertions(+), 15 deletions(-) diff --git a/MoreLinq/Append.cs b/MoreLinq/Append.cs index e0800b364..b081bbd83 100644 --- a/MoreLinq/Append.cs +++ b/MoreLinq/Append.cs @@ -38,18 +38,5 @@ public static IEnumerable Append(this IEnumerable head, T tail) ? node.Concat(tail) : PendNode.WithSource(head).Concat(tail); } - - /// - /// Returns a sequence consisting of the head elements and the given tail element. - /// - /// Type of sequence - /// All elements of the head. Must not be null. - /// Tail element of the new sequence. - /// A sequence consisting of the head elements and the given tail element. - /// This operator uses deferred execution and streams its results. - - [Obsolete("Use " + nameof(Append) + " instead.")] - public static IEnumerable Concat(this IEnumerable head, T tail) => - head.Append(tail); } } diff --git a/MoreLinq/CompatibilitySuppressions.xml b/MoreLinq/CompatibilitySuppressions.xml index 1d7bf3d3e..da1602414 100644 --- a/MoreLinq/CompatibilitySuppressions.xml +++ b/MoreLinq/CompatibilitySuppressions.xml @@ -1,6 +1,34 @@ + + CP0002 + M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) + lib/net462/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) + lib/net6.0/MoreLinq.dll + lib/net6.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) + lib/netstandard2.0/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) + lib/netstandard2.1/MoreLinq.dll + lib/netstandard2.1/MoreLinq.dll + true + PKV006 .NETStandard,Version=v1.0 diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt index 7dc5c5811..b4ddb014c 100644 --- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt @@ -1 +1,2 @@ #nullable enable +*REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt index 7dc5c5811..b4ddb014c 100644 --- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt @@ -1 +1,2 @@ #nullable enable +*REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt index 7dc5c5811..b4ddb014c 100644 --- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt @@ -1 +1,2 @@ #nullable enable +*REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! diff --git a/README.md b/README.md index ece3287fc..2c9962eda 100644 --- a/README.md +++ b/README.md @@ -167,8 +167,11 @@ first sequence has fewer, the same or more elements than the second sequence. Returns a sequence consisting of the head element and the given tail elements. -This method is obsolete and will be removed in a future version. Use `Append` -instead. +This extension was rendered obsolete in version 3.0 and eventually removed in +version 4.0. Use [`Append`][linq-append] from .NET instead that's been available +since .NET Standard 1.6+, .NET Core 1.0+ and .NET Framework 4.7.1+. + +[linq-append]: https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.append ### Consume From f7668273de76bcbdbecc95b0cb8f616a90479646 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 6 May 2023 10:42:52 +0200 Subject: [PATCH 098/157] Fix bug in "FillForward" when filler is null --- MoreLinq.Test/FillForwardTest.cs | 13 +++++++++++++ MoreLinq/FillForward.cs | 6 +++--- 2 files changed, 16 insertions(+), 3 deletions(-) diff --git a/MoreLinq.Test/FillForwardTest.cs b/MoreLinq.Test/FillForwardTest.cs index bd156f096..97c68f563 100644 --- a/MoreLinq.Test/FillForwardTest.cs +++ b/MoreLinq.Test/FillForwardTest.cs @@ -83,5 +83,18 @@ select line.Trim() into line new { Continent = "Africa", Country = "Kenya", City = "Nairobi", Value = 901 }, })); } + + /// + /// Exercises bug reported in issue #999. + /// + + [Test] + public void FillForwardWithNullFiller() + { + var input = new int?[] { null, 1, null, 2, null, 3, null }; + var result = input.FillForward(x => x is not null); + result.AssertSequenceEqual(Enumerable.Repeat((int?)null, input.Length)); + } } } diff --git a/MoreLinq/FillForward.cs b/MoreLinq/FillForward.cs index 6d304a366..a38faae49 100644 --- a/MoreLinq/FillForward.cs +++ b/MoreLinq/FillForward.cs @@ -112,10 +112,10 @@ static IEnumerable FillForwardImpl(IEnumerable source, Func pr { if (predicate(item)) { - yield return seed is (true, { } someSeed) + yield return seed is (true, var theSeed) ? fillSelector != null - ? fillSelector(item, someSeed) - : someSeed + ? fillSelector(item, theSeed) + : theSeed : item; } else From b9c3062bcf0ef9c82f14b60108529205a4ea1de5 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 20 Jun 2023 13:26:37 +0200 Subject: [PATCH 099/157] Dissolve schema query into distinct "ToDataTable" paths --- MoreLinq/ToDataTable.cs | 49 ++++++++++++++++++----------------------- 1 file changed, 22 insertions(+), 27 deletions(-) diff --git a/MoreLinq/ToDataTable.cs b/MoreLinq/ToDataTable.cs index 249488619..59a42b4fd 100644 --- a/MoreLinq/ToDataTable.cs +++ b/MoreLinq/ToDataTable.cs @@ -189,20 +189,6 @@ static MemberInfo[] BuildOrBindSchema(DataTable table, MemberInfo[] members) var columns = table.Columns; - var schemas = from m in members - select new - { - Member = m, - Type = (m.MemberType == MemberTypes.Property - ? ((PropertyInfo)m).PropertyType - : ((FieldInfo)m).FieldType) switch - { - var type when Nullable.GetUnderlyingType(type) is { } t => t, - var type => type, - }, - Column = columns[m.Name], - }; - // // If the table has no columns then build the schema. // If it has columns then validate members against the columns @@ -211,25 +197,34 @@ var type when Nullable.GetUnderlyingType(type) is { } t => t, if (columns.Count == 0) { - columns.AddRange(schemas.Select(m => new DataColumn(m.Member.Name, m.Type)).ToArray()); + foreach (var member in members) + _ = columns.Add(member.Name, GetElementaryTypeOfPropertyOrField(member)); + + return members; } - else - { - members = new MemberInfo[columns.Count]; - foreach (var info in schemas) - { - var member = info.Member; - var column = info.Column ?? throw new ArgumentException($"Column named '{member.Name}' is missing.", nameof(table)); + var columnMembers = new MemberInfo[columns.Count]; - if (info.Type != column.DataType) - throw new ArgumentException($"Column named '{member.Name}' has wrong data type. It should be {info.Type} when it is {column.DataType}.", nameof(table)); + foreach (var member in members) + { + var column = columns[member.Name] ?? throw new ArgumentException($"Column named '{member.Name}' is missing.", nameof(table)); - members[column.Ordinal] = member; - } + if (GetElementaryTypeOfPropertyOrField(member) is var type && type != column.DataType) + throw new ArgumentException($"Column named '{member.Name}' has wrong data type. It should be {type} when it is {column.DataType}.", nameof(table)); + + columnMembers[column.Ordinal] = member; } - return members; + return columnMembers; + + static Type GetElementaryTypeOfPropertyOrField(MemberInfo member) => + (member.MemberType == MemberTypes.Property ? ((PropertyInfo)member).PropertyType + : ((FieldInfo)member).FieldType) + switch + { + var type when Nullable.GetUnderlyingType(type) is { } ut => ut, + var type => type, + }; } static Func CreateShredder(IEnumerable members) From f59f7a5ad3079debd19a9911e88e35c3c7b1db64 Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Sun, 25 Jun 2023 09:32:22 -0500 Subject: [PATCH 100/157] Hide extensions that conflict with newer .NET versions This is a squashed merge of PR #945 that: - closes #565 - closes #738 Co-authored-by: Atif Aziz --- MoreLinq.Test/AppendTest.cs | 4 + MoreLinq.Test/DistinctByTest.cs | 4 + MoreLinq.Test/Enumerable.cs | 5 + MoreLinq.Test/PrependTest.cs | 4 + MoreLinq.Test/SkipLastTest.cs | 4 + MoreLinq.Test/TakeLastTest.cs | 4 + MoreLinq/Append.cs | 4 + MoreLinq/CompatibilitySuppressions.xml | 112 ++++++++++++++++++ MoreLinq/DistinctBy.cs | 12 +- MoreLinq/Prepend.cs | 4 + .../PublicAPI/net6.0/PublicAPI.Unshipped.txt | 16 +++ .../netstandard2.0/PublicAPI.Unshipped.txt | 4 + .../netstandard2.1/PublicAPI.Unshipped.txt | 12 ++ MoreLinq/SkipLast.cs | 4 + MoreLinq/TakeLast.cs | 4 + MoreLinq/ToHashSet.cs | 10 +- bld/ExtensionsGenerator/Program.cs | 11 +- 17 files changed, 215 insertions(+), 3 deletions(-) diff --git a/MoreLinq.Test/AppendTest.cs b/MoreLinq.Test/AppendTest.cs index 736ba6498..55ff31597 100644 --- a/MoreLinq.Test/AppendTest.cs +++ b/MoreLinq.Test/AppendTest.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#if !NET471_OR_GREATER && !NETSTANDARD1_6_OR_GREATER && !NETCOREAPP2_0_OR_GREATER + namespace MoreLinq.Test { using System.Collections.Generic; @@ -90,3 +92,5 @@ public void AppendWithSharedSource() } } } + +#endif diff --git a/MoreLinq.Test/DistinctByTest.cs b/MoreLinq.Test/DistinctByTest.cs index 7035578f2..377c9a318 100644 --- a/MoreLinq.Test/DistinctByTest.cs +++ b/MoreLinq.Test/DistinctByTest.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#if !NET6_0_OR_GREATER + namespace MoreLinq.Test { using System; @@ -61,3 +63,5 @@ public void DistinctByIsLazyWithComparer() } } } + +#endif diff --git a/MoreLinq.Test/Enumerable.cs b/MoreLinq.Test/Enumerable.cs index f7795af4e..ae22e31cd 100644 --- a/MoreLinq.Test/Enumerable.cs +++ b/MoreLinq.Test/Enumerable.cs @@ -45,6 +45,11 @@ public static bool Any(this IEnumerable source) => public static bool Any(this IEnumerable source, Func predicate) => LinqEnumerable.Any(source, predicate); +#if NET471_OR_GREATER || NET6_0_OR_GREATER + public static IEnumerable Append (this IEnumerable source, TSource element) => + LinqEnumerable.Append(source, element); +#endif + public static IEnumerable AsEnumerable(this IEnumerable source) => LinqEnumerable.AsEnumerable(source); diff --git a/MoreLinq.Test/PrependTest.cs b/MoreLinq.Test/PrependTest.cs index eaaad5c81..3a4f938d1 100644 --- a/MoreLinq.Test/PrependTest.cs +++ b/MoreLinq.Test/PrependTest.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#if !NET471_OR_GREATER && !NETSTANDARD1_6_OR_GREATER && !NETCOREAPP2_0_OR_GREATER + namespace MoreLinq.Test { using System.Collections.Generic; @@ -89,3 +91,5 @@ public void PrependWithSharedSource() } } } + +#endif diff --git a/MoreLinq.Test/SkipLastTest.cs b/MoreLinq.Test/SkipLastTest.cs index df7b19680..f6bbf7796 100644 --- a/MoreLinq.Test/SkipLastTest.cs +++ b/MoreLinq.Test/SkipLastTest.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#if !NETSTANDARD2_1 && !NETCOREAPP2_0_OR_GREATER + namespace MoreLinq.Test { using System.Collections.Generic; @@ -68,3 +70,5 @@ public void SkipLastUsesCollectionCountAtIterationTime() } } } + +#endif diff --git a/MoreLinq.Test/TakeLastTest.cs b/MoreLinq.Test/TakeLastTest.cs index 5779f4cfc..fc0347bf6 100644 --- a/MoreLinq.Test/TakeLastTest.cs +++ b/MoreLinq.Test/TakeLastTest.cs @@ -15,6 +15,8 @@ // limitations under the License. #endregion +#if !NETSTANDARD2_1 && !NETCOREAPP2_0_OR_GREATER + namespace MoreLinq.Test { using NUnit.Framework; @@ -89,3 +91,5 @@ static void AssertTakeLast(ICollection input, int count, ActionA sequence consisting of the head elements and the given tail element. /// This operator uses deferred execution and streams its results. +#if NET471_OR_GREATER || NETSTANDARD1_6_OR_GREATER || NETCOREAPP2_0_OR_GREATER + public static IEnumerable Append(IEnumerable head, T tail) +#else public static IEnumerable Append(this IEnumerable head, T tail) +#endif { if (head == null) throw new ArgumentNullException(nameof(head)); return head is PendNode node diff --git a/MoreLinq/CompatibilitySuppressions.xml b/MoreLinq/CompatibilitySuppressions.xml index da1602414..227399b89 100644 --- a/MoreLinq/CompatibilitySuppressions.xml +++ b/MoreLinq/CompatibilitySuppressions.xml @@ -1,6 +1,69 @@ + + CP0001 + T:MoreLinq.Extensions.AppendExtension + lib/net462/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + + + CP0001 + T:MoreLinq.Extensions.PrependExtension + lib/net462/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + + + CP0001 + T:MoreLinq.Extensions.AppendExtension + lib/net6.0/MoreLinq.dll + lib/net6.0/MoreLinq.dll + true + + + CP0001 + T:MoreLinq.Extensions.PrependExtension + lib/net6.0/MoreLinq.dll + lib/net6.0/MoreLinq.dll + true + + + CP0001 + T:MoreLinq.Extensions.AppendExtension + lib/netstandard2.0/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + + + CP0001 + T:MoreLinq.Extensions.PrependExtension + lib/netstandard2.0/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + + + CP0001 + T:MoreLinq.Extensions.AppendExtension + lib/netstandard2.1/MoreLinq.dll + lib/netstandard2.1/MoreLinq.dll + true + + + CP0001 + T:MoreLinq.Extensions.PrependExtension + lib/netstandard2.1/MoreLinq.dll + lib/netstandard2.1/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) + lib/net462/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + CP0002 M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) @@ -8,6 +71,20 @@ lib/netstandard2.0/MoreLinq.dll true + + CP0002 + M:MoreLinq.MoreEnumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0) + lib/net462/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) + lib/net6.0/MoreLinq.dll + lib/net6.0/MoreLinq.dll + true + CP0002 M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) @@ -15,6 +92,20 @@ lib/net6.0/MoreLinq.dll true + + CP0002 + M:MoreLinq.MoreEnumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0) + lib/net6.0/MoreLinq.dll + lib/net6.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) + lib/netstandard2.0/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + CP0002 M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) @@ -22,6 +113,20 @@ lib/netstandard2.0/MoreLinq.dll true + + CP0002 + M:MoreLinq.MoreEnumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0) + lib/netstandard2.0/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + + + CP0002 + M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) + lib/netstandard2.1/MoreLinq.dll + lib/netstandard2.1/MoreLinq.dll + true + CP0002 M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) @@ -29,6 +134,13 @@ lib/netstandard2.1/MoreLinq.dll true + + CP0002 + M:MoreLinq.MoreEnumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0) + lib/netstandard2.1/MoreLinq.dll + lib/netstandard2.1/MoreLinq.dll + true + PKV006 .NETStandard,Version=v1.0 diff --git a/MoreLinq/DistinctBy.cs b/MoreLinq/DistinctBy.cs index a05faab82..1079ff814 100644 --- a/MoreLinq/DistinctBy.cs +++ b/MoreLinq/DistinctBy.cs @@ -38,10 +38,15 @@ static partial class MoreEnumerable /// A sequence consisting of distinct elements from the source sequence, /// comparing them by the specified key projection. +#if NET6_0_OR_GREATER + public static IEnumerable DistinctBy(IEnumerable source, + Func keySelector) +#else public static IEnumerable DistinctBy(this IEnumerable source, Func keySelector) +#endif { - return source.DistinctBy(keySelector, null); + return DistinctBy(source, keySelector, null); } /// @@ -62,8 +67,13 @@ public static IEnumerable DistinctBy(this IEnumerableA sequence consisting of distinct elements from the source sequence, /// comparing them by the specified key projection. +#if NET6_0_OR_GREATER + public static IEnumerable DistinctBy(IEnumerable source, + Func keySelector, IEqualityComparer? comparer) +#else public static IEnumerable DistinctBy(this IEnumerable source, Func keySelector, IEqualityComparer? comparer) +#endif { if (source == null) throw new ArgumentNullException(nameof(source)); if (keySelector == null) throw new ArgumentNullException(nameof(keySelector)); diff --git a/MoreLinq/Prepend.cs b/MoreLinq/Prepend.cs index 06f5a0f27..fb82e8538 100644 --- a/MoreLinq/Prepend.cs +++ b/MoreLinq/Prepend.cs @@ -41,7 +41,11 @@ static partial class MoreEnumerable /// The result variable, when iterated over, will yield /// 0, 1, 2 and 3, in turn. +#if NET471_OR_GREATER || NETSTANDARD1_6_OR_GREATER || NETCOREAPP2_0_OR_GREATER + public static IEnumerable Prepend(IEnumerable source, TSource value) +#else public static IEnumerable Prepend(this IEnumerable source, TSource value) +#endif { if (source == null) throw new ArgumentNullException(nameof(source)); return source is PendNode node diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt index b4ddb014c..8959c7eec 100644 --- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt @@ -1,2 +1,18 @@ #nullable enable +*REMOVED*static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +*REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt index b4ddb014c..056e1801b 100644 --- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt @@ -1,2 +1,6 @@ #nullable enable +*REMOVED*static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt index b4ddb014c..b025e7aed 100644 --- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt @@ -1,2 +1,14 @@ #nullable enable +*REMOVED*static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +*REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! diff --git a/MoreLinq/SkipLast.cs b/MoreLinq/SkipLast.cs index 0483f3e74..c88cec5e4 100644 --- a/MoreLinq/SkipLast.cs +++ b/MoreLinq/SkipLast.cs @@ -33,7 +33,11 @@ static partial class MoreEnumerable /// An containing the source sequence elements except for the bypassed ones at the end. /// +#if NETSTANDARD2_1 || NETCOREAPP2_0_OR_GREATER + public static IEnumerable SkipLast(IEnumerable source, int count) +#else public static IEnumerable SkipLast(this IEnumerable source, int count) +#endif { if (source == null) throw new ArgumentNullException(nameof(source)); diff --git a/MoreLinq/TakeLast.cs b/MoreLinq/TakeLast.cs index 6619ff196..88eac7a8e 100644 --- a/MoreLinq/TakeLast.cs +++ b/MoreLinq/TakeLast.cs @@ -46,7 +46,11 @@ static partial class MoreEnumerable /// 56 and 78 in turn. /// +#if NETSTANDARD2_1 || NETCOREAPP2_0_OR_GREATER + public static IEnumerable TakeLast(IEnumerable source, int count) +#else public static IEnumerable TakeLast(this IEnumerable source, int count) +#endif { if (source == null) throw new ArgumentNullException(nameof(source)); diff --git a/MoreLinq/ToHashSet.cs b/MoreLinq/ToHashSet.cs index 7301ed357..1f6dc8bd1 100644 --- a/MoreLinq/ToHashSet.cs +++ b/MoreLinq/ToHashSet.cs @@ -35,9 +35,13 @@ static partial class MoreEnumerable /// This evaluates the input sequence completely. /// +#if NETSTANDARD2_1 || NET472_OR_GREATER || NETCOREAPP2_0_OR_GREATER + public static HashSet ToHashSet(IEnumerable source) +#else public static HashSet ToHashSet(this IEnumerable source) +#endif { - return source.ToHashSet(null); + return ToHashSet(source, null); } /// @@ -53,7 +57,11 @@ public static HashSet ToHashSet(this IEnumerable sour /// This evaluates the input sequence completely. /// +#if NETSTANDARD2_1 || NET472_OR_GREATER || NETCOREAPP2_0_OR_GREATER + public static HashSet ToHashSet(IEnumerable source, IEqualityComparer? comparer) +#else public static HashSet ToHashSet(this IEnumerable source, IEqualityComparer? comparer) +#endif { if (source == null) throw new ArgumentNullException(nameof(source)); return new HashSet(source, comparer); diff --git a/bld/ExtensionsGenerator/Program.cs b/bld/ExtensionsGenerator/Program.cs index f9cc083c2..87dba483d 100644 --- a/bld/ExtensionsGenerator/Program.cs +++ b/bld/ExtensionsGenerator/Program.cs @@ -235,7 +235,16 @@ from md in g select MethodDeclaration(md.ReturnType, md.Identifier) .WithAttributeLists(md.AttributeLists) - .WithModifiers(md.Modifiers) + .WithModifiers( + TokenList(md.Modifiers[0] // assume at least one modifier, like public + .WithLeadingTrivia( + from lt in md.Modifiers[0].LeadingTrivia + where lt.Kind() is not (SyntaxKind.DisabledTextTrivia + or SyntaxKind.IfDirectiveTrivia + or SyntaxKind.ElseDirectiveTrivia + or SyntaxKind.EndIfDirectiveTrivia) + select lt)) + .AddRange(md.Modifiers.Skip(1))) .WithTypeParameterList(md.TypeParameterList) .WithConstraintClauses(md.ConstraintClauses) .WithParameterList(md.ParameterList) From d739f65e4ebbc458647a1608c8f7bc2908784d82 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 20 Jun 2023 17:28:05 +0200 Subject: [PATCH 101/157] Fix schema binding signature in "ToDataTable" implementation --- MoreLinq/ToDataTable.cs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/MoreLinq/ToDataTable.cs b/MoreLinq/ToDataTable.cs index 59a42b4fd..476fdb9bd 100644 --- a/MoreLinq/ToDataTable.cs +++ b/MoreLinq/ToDataTable.cs @@ -103,8 +103,8 @@ public static TTable ToDataTable(this IEnumerable source, TTable t expressions ??= EmptyArray>>.Value; var members = PrepareMemberInfos(expressions).ToArray(); - members = BuildOrBindSchema(table, members); - var shredder = CreateShredder(members); + var boundMembers = BuildOrBindSchema(table, members); + var shredder = CreateShredder(boundMembers); // // Builds rows out of elements in the sequence and @@ -180,7 +180,7 @@ static MemberInfo GetAccessedMember(LambdaExpression lambda) /// columns for which there is no source member supplying a value. /// - static MemberInfo[] BuildOrBindSchema(DataTable table, MemberInfo[] members) + static MemberInfo?[] BuildOrBindSchema(DataTable table, MemberInfo[] members) { // // Retrieve member information needed to @@ -227,7 +227,7 @@ var type when Nullable.GetUnderlyingType(type) is { } ut => ut, }; } - static Func CreateShredder(IEnumerable members) + static Func CreateShredder(MemberInfo?[] members) { var parameter = Expression.Parameter(typeof(T), "e"); From e98d6322c75af1902359947661b85a867c40df50 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 26 Jun 2023 22:50:37 +0200 Subject: [PATCH 102/157] Re-enable tests for hidden extensions on all targets --- MoreLinq.Test/AggregateTest.cs | 1 + MoreLinq.Test/AppendTest.cs | 5 +---- MoreLinq.Test/DistinctByTest.cs | 5 +---- MoreLinq.Test/Enumerable.cs | 5 ----- MoreLinq.Test/GroupAdjacentTest.cs | 1 + MoreLinq.Test/PartialSortTest.cs | 1 + MoreLinq.Test/PrependTest.cs | 5 +---- MoreLinq.Test/SkipLastTest.cs | 5 +---- MoreLinq.Test/TakeLastTest.cs | 5 +---- 9 files changed, 8 insertions(+), 25 deletions(-) diff --git a/MoreLinq.Test/AggregateTest.cs b/MoreLinq.Test/AggregateTest.cs index 9ef7b2336..04ec29154 100644 --- a/MoreLinq.Test/AggregateTest.cs +++ b/MoreLinq.Test/AggregateTest.cs @@ -26,6 +26,7 @@ namespace MoreLinq.Test using System.Reactive.Linq; using System.Reflection; using NUnit.Framework.Interfaces; + using static MoreLinq.Extensions.AppendExtension; using static FuncModule; [TestFixture] diff --git a/MoreLinq.Test/AppendTest.cs b/MoreLinq.Test/AppendTest.cs index 55ff31597..58dbd6c9d 100644 --- a/MoreLinq.Test/AppendTest.cs +++ b/MoreLinq.Test/AppendTest.cs @@ -15,12 +15,11 @@ // limitations under the License. #endregion -#if !NET471_OR_GREATER && !NETSTANDARD1_6_OR_GREATER && !NETCOREAPP2_0_OR_GREATER - namespace MoreLinq.Test { using System.Collections.Generic; using NUnit.Framework; + using static MoreLinq.Extensions.AppendExtension; [TestFixture] public class AppendTest @@ -92,5 +91,3 @@ public void AppendWithSharedSource() } } } - -#endif diff --git a/MoreLinq.Test/DistinctByTest.cs b/MoreLinq.Test/DistinctByTest.cs index 377c9a318..70c684592 100644 --- a/MoreLinq.Test/DistinctByTest.cs +++ b/MoreLinq.Test/DistinctByTest.cs @@ -15,12 +15,11 @@ // limitations under the License. #endregion -#if !NET6_0_OR_GREATER - namespace MoreLinq.Test { using System; using NUnit.Framework; + using static MoreLinq.Extensions.DistinctByExtension; [TestFixture] public class DistinctByTest @@ -63,5 +62,3 @@ public void DistinctByIsLazyWithComparer() } } } - -#endif diff --git a/MoreLinq.Test/Enumerable.cs b/MoreLinq.Test/Enumerable.cs index ae22e31cd..f7795af4e 100644 --- a/MoreLinq.Test/Enumerable.cs +++ b/MoreLinq.Test/Enumerable.cs @@ -45,11 +45,6 @@ public static bool Any(this IEnumerable source) => public static bool Any(this IEnumerable source, Func predicate) => LinqEnumerable.Any(source, predicate); -#if NET471_OR_GREATER || NET6_0_OR_GREATER - public static IEnumerable Append (this IEnumerable source, TSource element) => - LinqEnumerable.Append(source, element); -#endif - public static IEnumerable AsEnumerable(this IEnumerable source) => LinqEnumerable.AsEnumerable(source); diff --git a/MoreLinq.Test/GroupAdjacentTest.cs b/MoreLinq.Test/GroupAdjacentTest.cs index d6da9909a..b3830a2d2 100644 --- a/MoreLinq.Test/GroupAdjacentTest.cs +++ b/MoreLinq.Test/GroupAdjacentTest.cs @@ -20,6 +20,7 @@ namespace MoreLinq.Test using System; using System.Collections.Generic; using NUnit.Framework; + using static MoreLinq.Extensions.AppendExtension; [TestFixture] public class GroupAdjacentTest diff --git a/MoreLinq.Test/PartialSortTest.cs b/MoreLinq.Test/PartialSortTest.cs index a838efdc3..555428fad 100644 --- a/MoreLinq.Test/PartialSortTest.cs +++ b/MoreLinq.Test/PartialSortTest.cs @@ -19,6 +19,7 @@ namespace MoreLinq.Test { using System; using NUnit.Framework; + using static MoreLinq.Extensions.AppendExtension; [TestFixture] public class PartialSortTests diff --git a/MoreLinq.Test/PrependTest.cs b/MoreLinq.Test/PrependTest.cs index 3a4f938d1..de8253f6e 100644 --- a/MoreLinq.Test/PrependTest.cs +++ b/MoreLinq.Test/PrependTest.cs @@ -15,13 +15,12 @@ // limitations under the License. #endregion -#if !NET471_OR_GREATER && !NETSTANDARD1_6_OR_GREATER && !NETCOREAPP2_0_OR_GREATER - namespace MoreLinq.Test { using System.Collections.Generic; using NUnit.Framework; using NUnit.Framework.Interfaces; + using static MoreLinq.Extensions.PrependExtension; [TestFixture] public class PrependTest @@ -91,5 +90,3 @@ public void PrependWithSharedSource() } } } - -#endif diff --git a/MoreLinq.Test/SkipLastTest.cs b/MoreLinq.Test/SkipLastTest.cs index f6bbf7796..94187ef75 100644 --- a/MoreLinq.Test/SkipLastTest.cs +++ b/MoreLinq.Test/SkipLastTest.cs @@ -15,12 +15,11 @@ // limitations under the License. #endregion -#if !NETSTANDARD2_1 && !NETCOREAPP2_0_OR_GREATER - namespace MoreLinq.Test { using System.Collections.Generic; using NUnit.Framework; + using static MoreLinq.Extensions.SkipLastExtension; [TestFixture] public class SkipLastTest @@ -70,5 +69,3 @@ public void SkipLastUsesCollectionCountAtIterationTime() } } } - -#endif diff --git a/MoreLinq.Test/TakeLastTest.cs b/MoreLinq.Test/TakeLastTest.cs index fc0347bf6..2c20f8137 100644 --- a/MoreLinq.Test/TakeLastTest.cs +++ b/MoreLinq.Test/TakeLastTest.cs @@ -15,13 +15,12 @@ // limitations under the License. #endregion -#if !NETSTANDARD2_1 && !NETCOREAPP2_0_OR_GREATER - namespace MoreLinq.Test { using NUnit.Framework; using System.Collections.Generic; using System; + using static MoreLinq.Extensions.TakeLastExtension; [TestFixture] public class TakeLastTest @@ -91,5 +90,3 @@ static void AssertTakeLast(ICollection input, int count, Action Date: Tue, 27 Jun 2023 08:35:39 +0200 Subject: [PATCH 103/157] Test "SortedMerge" does not call "MoveNext" eagerly --- MoreLinq.Test/SortedMergeTest.cs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/MoreLinq.Test/SortedMergeTest.cs b/MoreLinq.Test/SortedMergeTest.cs index a9ddb706b..7434df0c4 100644 --- a/MoreLinq.Test/SortedMergeTest.cs +++ b/MoreLinq.Test/SortedMergeTest.cs @@ -54,6 +54,21 @@ public void TestSortedMergeDisposesOnError() Throws.BreakException); } + /// + /// Verify that SortedMerge do not call MoveNext method eagerly + /// + [Test] + public void TestSortedMergeDoNotCallMoveNextEagerly() + { + using var sequenceA = TestingSequence.Of(1, 3); + using var sequenceB = MoreEnumerable.From(() => 2, () => throw new TestException()) + .AsTestingSequence(); + + var result = sequenceA.SortedMerge(OrderByDirection.Ascending, sequenceB).Take(2); + + Assert.That(() => result.Consume(), Throws.Nothing); + } + /// /// Verify that SortedMerge throws an exception if invoked on a null sequence. /// From 35fefdfffe5024b4ee5286a234c68204ac5382ce Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 27 Jun 2023 21:48:02 +0200 Subject: [PATCH 104/157] Update package validation tool to v1.0.12 --- .config/dotnet-tools.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json index 516b7dafe..87d6ac9db 100644 --- a/.config/dotnet-tools.json +++ b/.config/dotnet-tools.json @@ -15,7 +15,7 @@ ] }, "meziantou.framework.nugetpackagevalidation.tool": { - "version": "1.0.9", + "version": "1.0.12", "commands": [ "meziantou.validate-nuget-package" ] From 5eebc0af5f8614489e36cb734d808d03018526c9 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 14 Oct 2023 13:34:38 +0200 Subject: [PATCH 105/157] Suppress "EnableGenerateDocumentationFile" warning This is a workaround for dotnet/roslyn#41640. --- Directory.Build.props | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Directory.Build.props b/Directory.Build.props index 0b85fe477..ef2ed08ed 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -5,5 +5,7 @@ true 7.0-all true + + EnableGenerateDocumentationFile From 189a0546bdedf05a9fc5a387e55d813262f0749b Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 15 Oct 2023 10:19:46 +0200 Subject: [PATCH 106/157] Change "Batch" to return arrays This is a squashed merge or PR #1014 that closes #98. --- MoreLinq.Test/BatchTest.cs | 11 ---- MoreLinq/Batch.cs | 4 +- MoreLinq/CompatibilitySuppressions.xml | 56 +++++++++++++++++++ MoreLinq/Extensions.g.cs | 4 +- .../PublicAPI/net6.0/PublicAPI.Unshipped.txt | 8 +++ .../netstandard2.0/PublicAPI.Unshipped.txt | 8 +++ .../netstandard2.1/PublicAPI.Unshipped.txt | 8 +++ 7 files changed, 84 insertions(+), 15 deletions(-) diff --git a/MoreLinq.Test/BatchTest.cs b/MoreLinq.Test/BatchTest.cs index bd2db7127..ee10acfb2 100644 --- a/MoreLinq.Test/BatchTest.cs +++ b/MoreLinq.Test/BatchTest.cs @@ -62,17 +62,6 @@ public void BatchSequenceTransformingResult() result.AssertSequenceEqual(10, 26, 9); } - [Test] - public void BatchSequenceYieldsListsOfBatches() - { - var result = new[] { 1, 2, 3 }.Batch(2); - - using var reader = result.Read(); - Assert.That(reader.Read(), Is.InstanceOf(typeof(IList))); - Assert.That(reader.Read(), Is.InstanceOf(typeof(IList))); - reader.ReadEnd(); - } - [Test] public void BatchSequencesAreIndependentInstances() { diff --git a/MoreLinq/Batch.cs b/MoreLinq/Batch.cs index b8abf7f1e..5da60c07a 100644 --- a/MoreLinq/Batch.cs +++ b/MoreLinq/Batch.cs @@ -47,7 +47,7 @@ static partial class MoreEnumerable /// /// - public static IEnumerable> Batch(this IEnumerable source, int size) + public static IEnumerable Batch(this IEnumerable source, int size) { return Batch(source, size, IdFn); } @@ -80,7 +80,7 @@ public static IEnumerable> Batch(this IEnumerable< /// public static IEnumerable Batch(this IEnumerable source, int size, - Func, TResult> resultSelector) + Func resultSelector) { if (source == null) throw new ArgumentNullException(nameof(source)); if (size <= 0) throw new ArgumentOutOfRangeException(nameof(size)); diff --git a/MoreLinq/CompatibilitySuppressions.xml b/MoreLinq/CompatibilitySuppressions.xml index 227399b89..689b85169 100644 --- a/MoreLinq/CompatibilitySuppressions.xml +++ b/MoreLinq/CompatibilitySuppressions.xml @@ -57,6 +57,13 @@ lib/netstandard2.1/MoreLinq.dll true + + CP0002 + M:MoreLinq.Extensions.BatchExtension.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) + lib/net462/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + CP0002 M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) @@ -64,6 +71,13 @@ lib/netstandard2.0/MoreLinq.dll true + + CP0002 + M:MoreLinq.MoreEnumerable.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) + lib/net462/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + CP0002 M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) @@ -78,6 +92,13 @@ lib/netstandard2.0/MoreLinq.dll true + + CP0002 + M:MoreLinq.Extensions.BatchExtension.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) + lib/net6.0/MoreLinq.dll + lib/net6.0/MoreLinq.dll + true + CP0002 M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) @@ -85,6 +106,13 @@ lib/net6.0/MoreLinq.dll true + + CP0002 + M:MoreLinq.MoreEnumerable.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) + lib/net6.0/MoreLinq.dll + lib/net6.0/MoreLinq.dll + true + CP0002 M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) @@ -99,6 +127,13 @@ lib/net6.0/MoreLinq.dll true + + CP0002 + M:MoreLinq.Extensions.BatchExtension.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) + lib/netstandard2.0/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + CP0002 M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) @@ -106,6 +141,13 @@ lib/netstandard2.0/MoreLinq.dll true + + CP0002 + M:MoreLinq.MoreEnumerable.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) + lib/netstandard2.0/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + CP0002 M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) @@ -120,6 +162,13 @@ lib/netstandard2.0/MoreLinq.dll true + + CP0002 + M:MoreLinq.Extensions.BatchExtension.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) + lib/netstandard2.1/MoreLinq.dll + lib/netstandard2.1/MoreLinq.dll + true + CP0002 M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) @@ -127,6 +176,13 @@ lib/netstandard2.1/MoreLinq.dll true + + CP0002 + M:MoreLinq.MoreEnumerable.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) + lib/netstandard2.1/MoreLinq.dll + lib/netstandard2.1/MoreLinq.dll + true + CP0002 M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index b25c873fb..f492ce171 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -680,7 +680,7 @@ public static partial class BatchExtension /// /// - public static IEnumerable> Batch(this IEnumerable source, int size) + public static IEnumerable Batch(this IEnumerable source, int size) => MoreEnumerable.Batch(source, size); /// @@ -711,7 +711,7 @@ public static IEnumerable> Batch(this IEnumerable< /// public static IEnumerable Batch(this IEnumerable source, int size, - Func, TResult> resultSelector) + Func resultSelector) => MoreEnumerable.Batch(source, size, resultSelector); } diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt index 8959c7eec..fb44539c9 100644 --- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt @@ -1,5 +1,9 @@ #nullable enable +*REMOVED*static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! *REMOVED*static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! *REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! @@ -8,7 +12,11 @@ *REMOVED*static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! *REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt index 056e1801b..ecb558421 100644 --- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt @@ -1,6 +1,14 @@ #nullable enable +*REMOVED*static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! *REMOVED*static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! *REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt index b025e7aed..b2858b738 100644 --- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt @@ -1,12 +1,20 @@ #nullable enable +*REMOVED*static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! *REMOVED*static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! *REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! *REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! From 80335506aaed74b5af3b99b5e8653c62ccbd10e3 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Fri, 20 Oct 2023 18:50:11 +0200 Subject: [PATCH 107/157] Fix linking of some methods in read-me doc --- README.md | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 2c9962eda..9d1f76a44 100644 --- a/README.md +++ b/README.md @@ -34,10 +34,11 @@ using static MoreLinq.Extensions.LeadExtension; In the example above, only the [`Lag`][lag] and [`Lead`][lead] extension methods will be available in scope. -Apart from extension methods, MoreLINQ also offers regular static method -that *generate* (instead of operating on) sequences, like `Unfold`, -`Random`, `Sequence` and others. If you want to use these while statically -importing other individual extension methods, you can do so via aliasing: +Apart from extension methods, MoreLINQ also offers regular static method that +*generate* (instead of operating on) sequences, like [`Unfold`][unfold], +[`Random`][random], [`Sequence`][sequence] and others. If you want to use these +while statically importing other individual extension methods, you can do so via +aliasing: ```c# using static MoreLinq.Extensions.LagExtension; From 7d438eda053d7aeaf5269e9fb9866d4103327758 Mon Sep 17 00:00:00 2001 From: Orace Date: Sat, 21 Oct 2023 13:12:45 +0200 Subject: [PATCH 108/157] Fix "Subsets" to return an empty set when k = 0 This is a squashed merge of PR #646 that fixes #645. --------- Co-authored-by: Atif Aziz --- MoreLinq.Test/SubsetTest.cs | 13 +++++++++++++ MoreLinq/Subsets.cs | 4 ++-- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/MoreLinq.Test/SubsetTest.cs b/MoreLinq.Test/SubsetTest.cs index 4f55cb70b..5b35524bf 100644 --- a/MoreLinq.Test/SubsetTest.cs +++ b/MoreLinq.Test/SubsetTest.cs @@ -131,6 +131,19 @@ public void TestAllSubsetsExpectedResults() Assert.That(subset, Is.EqualTo(expectedSubsets[index++])); } + /// + /// See issue #645. + /// + [Test] + public void Test0SubsetIsEmptyList() + { + var sequence = Enumerable.Range(1, 4); + var actual = sequence.Subsets(0); + + // For any set there is always 1 subset of size 0: the empty set. + actual.AssertSequenceEqual(new int[0]); + } + /// /// Verify that the number of subsets for a given subset-size is correct. /// diff --git a/MoreLinq/Subsets.cs b/MoreLinq/Subsets.cs index bb5752723..7852dd3c2 100644 --- a/MoreLinq/Subsets.cs +++ b/MoreLinq/Subsets.cs @@ -166,7 +166,7 @@ public void Reset() _k = _subset.Length; _n = _set.Count; _z = _n - _k + 1; - _continue = _subset.Length > 0; + _continue = true; } public IList Current => (IList)_subset.Clone(); @@ -198,7 +198,7 @@ public bool MoveNext() ExtractSubset(); - _continue = _indices[0] != _z; + _continue = _indices.Length > 0 && _indices[0] != _z; return true; } From dd8e8a89bfb13af9f6082b6911460eb06e9bae69 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 23 Oct 2023 21:32:51 +0200 Subject: [PATCH 109/157] Remove "Windowed" that's superseded by "Window" This is a squashed merge of PR #1017 that closes #1016. --- MoreLinq/CompatibilitySuppressions.xml | 28 +++++++++++++++++++ .../PublicAPI/net6.0/PublicAPI.Unshipped.txt | 1 + .../netstandard2.0/PublicAPI.Unshipped.txt | 1 + .../netstandard2.1/PublicAPI.Unshipped.txt | 1 + MoreLinq/Window.cs | 20 ------------- README.md | 3 +- 6 files changed, 32 insertions(+), 22 deletions(-) diff --git a/MoreLinq/CompatibilitySuppressions.xml b/MoreLinq/CompatibilitySuppressions.xml index 689b85169..ead8c1613 100644 --- a/MoreLinq/CompatibilitySuppressions.xml +++ b/MoreLinq/CompatibilitySuppressions.xml @@ -92,6 +92,13 @@ lib/netstandard2.0/MoreLinq.dll true + + CP0002 + M:MoreLinq.MoreEnumerable.Windowed``1(System.Collections.Generic.IEnumerable{``0},System.Int32) + lib/net462/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + CP0002 M:MoreLinq.Extensions.BatchExtension.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) @@ -127,6 +134,13 @@ lib/net6.0/MoreLinq.dll true + + CP0002 + M:MoreLinq.MoreEnumerable.Windowed``1(System.Collections.Generic.IEnumerable{``0},System.Int32) + lib/net6.0/MoreLinq.dll + lib/net6.0/MoreLinq.dll + true + CP0002 M:MoreLinq.Extensions.BatchExtension.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) @@ -162,6 +176,13 @@ lib/netstandard2.0/MoreLinq.dll true + + CP0002 + M:MoreLinq.MoreEnumerable.Windowed``1(System.Collections.Generic.IEnumerable{``0},System.Int32) + lib/netstandard2.0/MoreLinq.dll + lib/netstandard2.0/MoreLinq.dll + true + CP0002 M:MoreLinq.Extensions.BatchExtension.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) @@ -197,6 +218,13 @@ lib/netstandard2.1/MoreLinq.dll true + + CP0002 + M:MoreLinq.MoreEnumerable.Windowed``1(System.Collections.Generic.IEnumerable{``0},System.Int32) + lib/netstandard2.1/MoreLinq.dll + lib/netstandard2.1/MoreLinq.dll + true + PKV006 .NETStandard,Version=v1.0 diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt index fb44539c9..c2a9e629e 100644 --- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt @@ -12,6 +12,7 @@ *REMOVED*static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! *REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +*REMOVED*static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt index ecb558421..fa0a2a28d 100644 --- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt @@ -6,6 +6,7 @@ *REMOVED*static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! *REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt index b2858b738..85be22323 100644 --- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt @@ -10,6 +10,7 @@ *REMOVED*static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! *REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +*REMOVED*static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/Window.cs b/MoreLinq/Window.cs index b7db91a85..04b1ddefd 100644 --- a/MoreLinq/Window.cs +++ b/MoreLinq/Window.cs @@ -73,25 +73,5 @@ public static IEnumerable> Window(this IEnumerable - /// Processes a sequence into a series of sub-sequences representing a windowed subset of the original. - /// - /// The type of the elements of the source sequence. - /// The sequence to evaluate a sliding window over. - /// The size (number of elements) in each window. - /// - /// A series of sequences representing each sliding window subsequence. - /// - /// - /// The number of sequences returned is: Max(0, sequence.Count() - windowSize) + - /// 1 - /// - /// Returned sub-sequences are buffered, but the overall operation is streamed. - /// - - [Obsolete("Use " + nameof(Window) + " instead.")] - public static IEnumerable> Windowed(this IEnumerable source, int size) => - source.Window(size); } } diff --git a/README.md b/README.md index 9d1f76a44..de6b4e622 100644 --- a/README.md +++ b/README.md @@ -693,8 +693,7 @@ subset of the original Processes a sequence into a series of subsequences representing a windowed subset of the original -This method is obsolete and will be removed in a future version. Use `Window` -instead. +This method was removed and has been superseded by [`Window`](#window) instead. ### WindowLeft From 137564f07e7b7110bc552b8105a8e51726d1b71e Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 23 Oct 2023 22:43:03 +0200 Subject: [PATCH 110/157] Validate "expressions" of "ToDataTable" This is a squashed merge of PR #1021 that fixes #802. --- MoreLinq.Test/NullArgumentTest.cs | 1 - MoreLinq/ToDataTable.cs | 5 +---- 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/MoreLinq.Test/NullArgumentTest.cs b/MoreLinq.Test/NullArgumentTest.cs index 9cd3ec8cd..13a9aa364 100644 --- a/MoreLinq.Test/NullArgumentTest.cs +++ b/MoreLinq.Test/NullArgumentTest.cs @@ -124,7 +124,6 @@ static bool CanBeNull(ParameterInfo parameter) nameof(MoreEnumerable.From) + ".function1", nameof(MoreEnumerable.From) + ".function2", nameof(MoreEnumerable.From) + ".function3", - nameof(MoreEnumerable.ToDataTable) + ".expressions", nameof(MoreEnumerable.Trace) + ".format" }; diff --git a/MoreLinq/ToDataTable.cs b/MoreLinq/ToDataTable.cs index 476fdb9bd..08027567c 100644 --- a/MoreLinq/ToDataTable.cs +++ b/MoreLinq/ToDataTable.cs @@ -97,10 +97,7 @@ public static TTable ToDataTable(this IEnumerable source, TTable t { if (source == null) throw new ArgumentNullException(nameof(source)); if (table == null) throw new ArgumentNullException(nameof(table)); - - // TODO disallow null for "expressions" in next major update - - expressions ??= EmptyArray>>.Value; + if (expressions == null) throw new ArgumentNullException(nameof(expressions)); var members = PrepareMemberInfos(expressions).ToArray(); var boundMembers = BuildOrBindSchema(table, members); From 66f7cab9fb16c64b3f7b305904b6dfab48cd9fdf Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 24 Oct 2023 08:26:05 +0200 Subject: [PATCH 111/157] Add "Minima" & "Maxima" that supersede "MinBy" & "MaxBy" This is a squashed merge of PR #1019 that closes #1018. --- MoreLinq.Test/{MaxByTest.cs => MaximaTest.cs} | 68 ++-- MoreLinq.Test/{MinByTest.cs => MinimaTest.cs} | 68 ++-- MoreLinq/Extensions.g.cs | 106 ++++- MoreLinq/ExtremaMembers.cs | 25 ++ MoreLinq/MaxBy.cs | 317 +-------------- MoreLinq/Maxima.cs | 368 ++++++++++++++++++ MoreLinq/MinBy.cs | 23 +- MoreLinq/Minima.cs | 74 ++++ MoreLinq/MoreLinq.csproj | 4 +- .../PublicAPI/net6.0/PublicAPI.Unshipped.txt | 18 + .../netstandard2.0/PublicAPI.Unshipped.txt | 10 + .../netstandard2.1/PublicAPI.Unshipped.txt | 10 + README.md | 22 +- bld/ExtensionsGenerator/Program.cs | 1 - 14 files changed, 734 insertions(+), 380 deletions(-) rename MoreLinq.Test/{MaxByTest.cs => MaximaTest.cs} (77%) rename MoreLinq.Test/{MinByTest.cs => MinimaTest.cs} (77%) create mode 100644 MoreLinq/ExtremaMembers.cs create mode 100644 MoreLinq/Maxima.cs create mode 100644 MoreLinq/Minima.cs diff --git a/MoreLinq.Test/MaxByTest.cs b/MoreLinq.Test/MaximaTest.cs similarity index 77% rename from MoreLinq.Test/MaxByTest.cs rename to MoreLinq.Test/MaximaTest.cs index 6934c6773..272bbf5a3 100644 --- a/MoreLinq.Test/MaxByTest.cs +++ b/MoreLinq.Test/MaximaTest.cs @@ -20,44 +20,44 @@ namespace MoreLinq.Test using NUnit.Framework; [TestFixture] - public class MaxByTest + public class MaximaTest { [Test] - public void MaxByIsLazy() + public void MaximaIsLazy() { - _ = new BreakingSequence().MaxBy(BreakingFunc.Of()); + _ = new BreakingSequence().Maxima(BreakingFunc.Of()); } [Test] - public void MaxByReturnsMaxima() + public void MaximaReturnsMaxima() { - Assert.That(SampleData.Strings.MaxBy(x => x.Length), + Assert.That(SampleData.Strings.Maxima(x => x.Length), Is.EqualTo(new[] { "hello", "world" })); } [Test] - public void MaxByNullComparer() + public void MaximaNullComparer() { - Assert.That(SampleData.Strings.MaxBy(x => x.Length, null), - Is.EqualTo(SampleData.Strings.MaxBy(x => x.Length))); + Assert.That(SampleData.Strings.Maxima(x => x.Length, null), + Is.EqualTo(SampleData.Strings.Maxima(x => x.Length))); } [Test] - public void MaxByEmptySequence() + public void MaximaEmptySequence() { - Assert.That(new string[0].MaxBy(x => x.Length), Is.Empty); + Assert.That(new string[0].Maxima(x => x.Length), Is.Empty); } [Test] - public void MaxByWithNaturalComparer() + public void MaximaWithNaturalComparer() { - Assert.That(SampleData.Strings.MaxBy(x => x[1]), Is.EqualTo(new[] { "az" })); + Assert.That(SampleData.Strings.Maxima(x => x[1]), Is.EqualTo(new[] { "az" })); } [Test] - public void MaxByWithComparer() + public void MaximaWithComparer() { - Assert.That(SampleData.Strings.MaxBy(x => x[1], Comparable.DescendingOrderComparer), Is.EqualTo(new[] { "aa" })); + Assert.That(SampleData.Strings.Maxima(x => x[1], Comparable.DescendingOrderComparer), Is.EqualTo(new[] { "aa" })); } public class First @@ -66,7 +66,7 @@ public class First public void ReturnsMaximum() { using var strings = SampleData.Strings.AsTestingSequence(); - var maxima = strings.MaxBy(s => s.Length); + var maxima = strings.Maxima(s => s.Length); Assert.That(MoreEnumerable.First(maxima), Is.EqualTo("hello")); } @@ -74,7 +74,7 @@ public void ReturnsMaximum() public void WithComparerReturnsMaximum() { using var strings = SampleData.Strings.AsTestingSequence(); - var maxima = strings.MaxBy(s => s.Length, Comparable.DescendingOrderComparer); + var maxima = strings.Maxima(s => s.Length, Comparable.DescendingOrderComparer); Assert.That(MoreEnumerable.First(maxima), Is.EqualTo("ax")); } @@ -83,7 +83,7 @@ public void WithEmptySourceThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); Assert.That(() => - MoreEnumerable.First(strings.MaxBy(s => s.Length)), + MoreEnumerable.First(strings.Maxima(s => s.Length)), Throws.InvalidOperationException); } @@ -92,7 +92,7 @@ public void WithEmptySourceWithComparerThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); Assert.That(() => - MoreEnumerable.First(strings.MaxBy(s => s.Length, Comparable.DescendingOrderComparer)), + MoreEnumerable.First(strings.Maxima(s => s.Length, Comparable.DescendingOrderComparer)), Throws.InvalidOperationException); } } @@ -103,7 +103,7 @@ public class FirstOrDefault public void ReturnsMaximum() { using var strings = SampleData.Strings.AsTestingSequence(); - var maxima = strings.MaxBy(s => s.Length); + var maxima = strings.Maxima(s => s.Length); Assert.That(MoreEnumerable.FirstOrDefault(maxima), Is.EqualTo("hello")); } @@ -111,7 +111,7 @@ public void ReturnsMaximum() public void WithComparerReturnsMaximum() { using var strings = SampleData.Strings.AsTestingSequence(); - var maxima = strings.MaxBy(s => s.Length, Comparable.DescendingOrderComparer); + var maxima = strings.Maxima(s => s.Length, Comparable.DescendingOrderComparer); Assert.That(MoreEnumerable.FirstOrDefault(maxima), Is.EqualTo("ax")); } @@ -119,7 +119,7 @@ public void WithComparerReturnsMaximum() public void WithEmptySourceReturnsDefault() { using var strings = Enumerable.Empty().AsTestingSequence(); - var maxima = strings.MaxBy(s => s.Length); + var maxima = strings.Maxima(s => s.Length); Assert.That(MoreEnumerable.FirstOrDefault(maxima), Is.Null); } @@ -127,7 +127,7 @@ public void WithEmptySourceReturnsDefault() public void WithEmptySourceWithComparerReturnsDefault() { using var strings = Enumerable.Empty().AsTestingSequence(); - var maxima = strings.MaxBy(s => s.Length, Comparable.DescendingOrderComparer); + var maxima = strings.Maxima(s => s.Length, Comparable.DescendingOrderComparer); Assert.That(MoreEnumerable.FirstOrDefault(maxima), Is.Null); } } @@ -138,7 +138,7 @@ public class Last public void ReturnsMaximum() { using var strings = SampleData.Strings.AsTestingSequence(); - var maxima = strings.MaxBy(s => s.Length); + var maxima = strings.Maxima(s => s.Length); Assert.That(MoreEnumerable.Last(maxima), Is.EqualTo("world")); } @@ -146,7 +146,7 @@ public void ReturnsMaximum() public void WithComparerReturnsMaximumPerComparer() { using var strings = SampleData.Strings.AsTestingSequence(); - var maxima = strings.MaxBy(s => s.Length, Comparable.DescendingOrderComparer); + var maxima = strings.Maxima(s => s.Length, Comparable.DescendingOrderComparer); Assert.That(MoreEnumerable.Last(maxima), Is.EqualTo("az")); } @@ -155,7 +155,7 @@ public void WithEmptySourceThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); Assert.That(() => - MoreEnumerable.Last(strings.MaxBy(s => s.Length)), + MoreEnumerable.Last(strings.Maxima(s => s.Length)), Throws.InvalidOperationException); } @@ -164,7 +164,7 @@ public void WithEmptySourceWithComparerThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); Assert.That(() => - MoreEnumerable.Last(strings.MaxBy(s => s.Length, Comparable.DescendingOrderComparer)), + MoreEnumerable.Last(strings.Maxima(s => s.Length, Comparable.DescendingOrderComparer)), Throws.InvalidOperationException); } } @@ -175,7 +175,7 @@ public class LastOrDefault public void ReturnsMaximum() { using var strings = SampleData.Strings.AsTestingSequence(); - var maxima = strings.MaxBy(s => s.Length); + var maxima = strings.Maxima(s => s.Length); Assert.That(MoreEnumerable.LastOrDefault(maxima), Is.EqualTo("world")); } @@ -183,7 +183,7 @@ public void ReturnsMaximum() public void WithComparerReturnsMaximumPerComparer() { using var strings = SampleData.Strings.AsTestingSequence(); - var maxima = strings.MaxBy(s => s.Length, Comparable.DescendingOrderComparer); + var maxima = strings.Maxima(s => s.Length, Comparable.DescendingOrderComparer); Assert.That(MoreEnumerable.LastOrDefault(maxima), Is.EqualTo("az")); } @@ -191,7 +191,7 @@ public void WithComparerReturnsMaximumPerComparer() public void WithEmptySourceReturnsDefault() { using var strings = Enumerable.Empty().AsTestingSequence(); - var maxima = strings.MaxBy(s => s.Length); + var maxima = strings.Maxima(s => s.Length); Assert.That(MoreEnumerable.LastOrDefault(maxima), Is.Null); } @@ -199,7 +199,7 @@ public void WithEmptySourceReturnsDefault() public void WithEmptySourceWithComparerReturnsDefault() { using var strings = Enumerable.Empty().AsTestingSequence(); - var maxima = strings.MaxBy(s => s.Length, Comparable.DescendingOrderComparer); + var maxima = strings.Maxima(s => s.Length, Comparable.DescendingOrderComparer); Assert.That(MoreEnumerable.LastOrDefault(maxima), Is.Null); } } @@ -213,7 +213,7 @@ public class Take public string[] ReturnsMaxima(int count) { using var strings = SampleData.Strings.AsTestingSequence(); - return strings.MaxBy(s => s.Length).Take(count).ToArray(); + return strings.Maxima(s => s.Length).Take(count).ToArray(); } [TestCase(0, 0, ExpectedResult = new string[0] )] @@ -227,7 +227,7 @@ public string[] ReturnsMaxima(int count) public string[] WithComparerReturnsMaximaPerComparer(int count, int index) { using var strings = SampleData.Strings.AsTestingSequence(); - return strings.MaxBy(s => s[index], Comparable.DescendingOrderComparer) + return strings.Maxima(s => s[index], Comparable.DescendingOrderComparer) .Take(count) .ToArray(); } @@ -242,7 +242,7 @@ public class TakeLast public string[] TakeLastReturnsMaxima(int count) { using var strings = SampleData.Strings.AsTestingSequence(); - return strings.MaxBy(s => s.Length).TakeLast(count).ToArray(); + return strings.Maxima(s => s.Length).TakeLast(count).ToArray(); } [TestCase(0, 0, ExpectedResult = new string[0] )] @@ -256,7 +256,7 @@ public string[] TakeLastReturnsMaxima(int count) public string[] WithComparerReturnsMaximaPerComparer(int count, int index) { using var strings = SampleData.Strings.AsTestingSequence(); - return strings.MaxBy(s => s[index], Comparable.DescendingOrderComparer) + return strings.Maxima(s => s[index], Comparable.DescendingOrderComparer) .TakeLast(count) .ToArray(); } diff --git a/MoreLinq.Test/MinByTest.cs b/MoreLinq.Test/MinimaTest.cs similarity index 77% rename from MoreLinq.Test/MinByTest.cs rename to MoreLinq.Test/MinimaTest.cs index a549f1387..29caba348 100644 --- a/MoreLinq.Test/MinByTest.cs +++ b/MoreLinq.Test/MinimaTest.cs @@ -20,44 +20,44 @@ namespace MoreLinq.Test using NUnit.Framework; [TestFixture] - public class MinByTest + public class MinimaTest { [Test] - public void MinByIsLazy() + public void MinimaIsLazy() { - _ = new BreakingSequence().MinBy(BreakingFunc.Of()); + _ = new BreakingSequence().Minima(BreakingFunc.Of()); } [Test] - public void MinByReturnsMinima() + public void MinimaReturnsMinima() { - Assert.That(SampleData.Strings.MinBy(x => x.Length), + Assert.That(SampleData.Strings.Minima(x => x.Length), Is.EqualTo(new[] { "ax", "aa", "ab", "ay", "az" })); } [Test] - public void MinByNullComparer() + public void MinimaNullComparer() { - Assert.That(SampleData.Strings.MinBy(x => x.Length, null), - Is.EqualTo(SampleData.Strings.MinBy(x => x.Length))); + Assert.That(SampleData.Strings.Minima(x => x.Length, null), + Is.EqualTo(SampleData.Strings.Minima(x => x.Length))); } [Test] - public void MinByEmptySequence() + public void MinimaEmptySequence() { - Assert.That(new string[0].MinBy(x => x.Length), Is.Empty); + Assert.That(new string[0].Minima(x => x.Length), Is.Empty); } [Test] - public void MinByWithNaturalComparer() + public void MinimaWithNaturalComparer() { - Assert.That(SampleData.Strings.MinBy(x => x[1]), Is.EqualTo(new[] { "aa" })); + Assert.That(SampleData.Strings.Minima(x => x[1]), Is.EqualTo(new[] { "aa" })); } [Test] - public void MinByWithComparer() + public void MinimaWithComparer() { - Assert.That(SampleData.Strings.MinBy(x => x[1], Comparable.DescendingOrderComparer), Is.EqualTo(new[] { "az" })); + Assert.That(SampleData.Strings.Minima(x => x[1], Comparable.DescendingOrderComparer), Is.EqualTo(new[] { "az" })); } public class First @@ -66,7 +66,7 @@ public class First public void ReturnsMinimum() { using var strings = SampleData.Strings.AsTestingSequence(); - var minima = MoreEnumerable.First(strings.MinBy(s => s.Length)); + var minima = MoreEnumerable.First(strings.Minima(s => s.Length)); Assert.That(minima, Is.EqualTo("ax")); } @@ -74,7 +74,7 @@ public void ReturnsMinimum() public void WithComparerReturnsMinimum() { using var strings = SampleData.Strings.AsTestingSequence(); - var minima = strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer); + var minima = strings.Minima(s => s.Length, Comparable.DescendingOrderComparer); Assert.That(MoreEnumerable.First(minima), Is.EqualTo("hello")); } @@ -82,7 +82,7 @@ public void WithComparerReturnsMinimum() public void WithEmptySourceThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); - Assert.That(() => MoreEnumerable.First(strings.MinBy(s => s.Length)), + Assert.That(() => MoreEnumerable.First(strings.Minima(s => s.Length)), Throws.InvalidOperationException); } @@ -90,7 +90,7 @@ public void WithEmptySourceThrows() public void WithEmptySourceWithComparerThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); - Assert.That(() => MoreEnumerable.First(strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer)), + Assert.That(() => MoreEnumerable.First(strings.Minima(s => s.Length, Comparable.DescendingOrderComparer)), Throws.InvalidOperationException); } } @@ -101,7 +101,7 @@ public class FirstOrDefault public void ReturnsMinimum() { using var strings = SampleData.Strings.AsTestingSequence(); - var minima = strings.MinBy(s => s.Length); + var minima = strings.Minima(s => s.Length); Assert.That(MoreEnumerable.FirstOrDefault(minima), Is.EqualTo("ax")); } @@ -109,7 +109,7 @@ public void ReturnsMinimum() public void WithComparerReturnsMinimum() { using var strings = SampleData.Strings.AsTestingSequence(); - var minima = strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer); + var minima = strings.Minima(s => s.Length, Comparable.DescendingOrderComparer); Assert.That(MoreEnumerable.FirstOrDefault(minima), Is.EqualTo("hello")); } @@ -117,7 +117,7 @@ public void WithComparerReturnsMinimum() public void WithEmptySourceReturnsDefault() { using var strings = Enumerable.Empty().AsTestingSequence(); - var minima = strings.MinBy(s => s.Length); + var minima = strings.Minima(s => s.Length); Assert.That(MoreEnumerable.FirstOrDefault(minima), Is.Null); } @@ -125,7 +125,7 @@ public void WithEmptySourceReturnsDefault() public void WithEmptySourceWithComparerReturnsDefault() { using var strings = Enumerable.Empty().AsTestingSequence(); - var minima = strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer); + var minima = strings.Minima(s => s.Length, Comparable.DescendingOrderComparer); Assert.That(MoreEnumerable.FirstOrDefault(minima), Is.Null); } } @@ -136,7 +136,7 @@ public class Last public void ReturnsMinimum() { using var strings = SampleData.Strings.AsTestingSequence(); - var minima = strings.MinBy(s => s.Length); + var minima = strings.Minima(s => s.Length); Assert.That(MoreEnumerable.Last(minima), Is.EqualTo("az")); } @@ -144,7 +144,7 @@ public void ReturnsMinimum() public void WithComparerReturnsMinimumPerComparer() { using var strings = SampleData.Strings.AsTestingSequence(); - var minima = strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer); + var minima = strings.Minima(s => s.Length, Comparable.DescendingOrderComparer); Assert.That(MoreEnumerable.Last(minima), Is.EqualTo("world")); } @@ -152,7 +152,7 @@ public void WithComparerReturnsMinimumPerComparer() public void WithEmptySourceThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); - Assert.That(() => MoreEnumerable.Last(strings.MinBy(s => s.Length)), + Assert.That(() => MoreEnumerable.Last(strings.Minima(s => s.Length)), Throws.InvalidOperationException); } @@ -160,7 +160,7 @@ public void WithEmptySourceThrows() public void WithEmptySourceWithComparerThrows() { using var strings = Enumerable.Empty().AsTestingSequence(); - Assert.That(() => MoreEnumerable.Last(strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer)), + Assert.That(() => MoreEnumerable.Last(strings.Minima(s => s.Length, Comparable.DescendingOrderComparer)), Throws.InvalidOperationException); } } @@ -171,7 +171,7 @@ public class LastOrDefault public void ReturnsMinimum() { using var strings = SampleData.Strings.AsTestingSequence(); - var minima = strings.MinBy(s => s.Length); + var minima = strings.Minima(s => s.Length); Assert.That(MoreEnumerable.LastOrDefault(minima), Is.EqualTo("az")); } @@ -179,7 +179,7 @@ public void ReturnsMinimum() public void WithComparerReturnsMinimumPerComparer() { using var strings = SampleData.Strings.AsTestingSequence(); - var minima = strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer); + var minima = strings.Minima(s => s.Length, Comparable.DescendingOrderComparer); Assert.That(MoreEnumerable.LastOrDefault(minima), Is.EqualTo("world")); } @@ -187,7 +187,7 @@ public void WithComparerReturnsMinimumPerComparer() public void WithEmptySourceReturnsDefault() { using var strings = Enumerable.Empty().AsTestingSequence(); - var minima = strings.MinBy(s => s.Length); + var minima = strings.Minima(s => s.Length); Assert.That(MoreEnumerable.LastOrDefault(minima), Is.Null); } @@ -195,7 +195,7 @@ public void WithEmptySourceReturnsDefault() public void WithEmptySourceWithComparerReturnsDefault() { using var strings = Enumerable.Empty().AsTestingSequence(); - var minima = strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer); + var minima = strings.Minima(s => s.Length, Comparable.DescendingOrderComparer); Assert.That(MoreEnumerable.LastOrDefault(minima), Is.Null); } } @@ -212,7 +212,7 @@ public class Take public string[] ReturnsMinima(int count) { using var strings = SampleData.Strings.AsTestingSequence(); - return strings.MinBy(s => s.Length).Take(count).ToArray(); + return strings.Minima(s => s.Length).Take(count).ToArray(); } [TestCase(0, ExpectedResult = new string[0] )] @@ -222,7 +222,7 @@ public string[] ReturnsMinima(int count) public string[] WithComparerReturnsMinimaPerComparer(int count) { using var strings = SampleData.Strings.AsTestingSequence(); - return strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer) + return strings.Minima(s => s.Length, Comparable.DescendingOrderComparer) .Take(count) .ToArray(); } @@ -240,7 +240,7 @@ public class TakeLast public string[] ReturnsMinima(int count) { using var strings = SampleData.Strings.AsTestingSequence(); - return strings.MinBy(s => s.Length).TakeLast(count).ToArray(); + return strings.Minima(s => s.Length).TakeLast(count).ToArray(); } [TestCase(0, ExpectedResult = new string[0] )] @@ -250,7 +250,7 @@ public string[] ReturnsMinima(int count) public string[] WithComparerReturnsMinimaPerComparer(int count) { using var strings = SampleData.Strings.AsTestingSequence(); - return strings.MinBy(s => s.Length, Comparable.DescendingOrderComparer) + return strings.Minima(s => s.Length, Comparable.DescendingOrderComparer) .TakeLast(count) .ToArray(); } diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index f492ce171..b7fcf096d 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -3401,7 +3401,6 @@ public static IEnumerable LeftJoin( [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")] public static partial class MaxByExtension { - /// /// Returns the maximal elements of the given sequence, based on /// the given projection. @@ -3418,6 +3417,8 @@ public static partial class MaxByExtension /// The sequence of maximal elements, according to the projection. /// or is null + [Obsolete($"Use {nameof(ExtremaMembers.Maxima)} instead.")] + [ExcludeFromCodeCoverage] public static IExtremaEnumerable MaxBy(this IEnumerable source, Func selector) => MoreEnumerable.MaxBy(source, selector); @@ -3439,12 +3440,63 @@ public static IExtremaEnumerable MaxBy(this IEnumerable< /// , /// or is null + [Obsolete($"Use {nameof(ExtremaMembers.Maxima)} instead.")] + [ExcludeFromCodeCoverage] public static IExtremaEnumerable MaxBy(this IEnumerable source, Func selector, IComparer? comparer) => MoreEnumerable.MaxBy(source, selector, comparer); } + /// Maxima extension. + + [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")] + public static partial class MaximaExtension + { + + /// + /// Returns the maximal elements of the given sequence, based on + /// the given projection. + /// + /// + /// This overload uses the default comparer for the projected type. + /// This operator uses deferred execution. The results are evaluated + /// and cached on first use to returned sequence. + /// + /// Type of the source sequence + /// Type of the projected element + /// Source sequence + /// Selector to use to pick the results to compare + /// The sequence of maximal elements, according to the projection. + /// or is null + + public static IExtremaEnumerable Maxima(this IEnumerable source, + Func selector) + => MoreEnumerable.Maxima(source, selector); + + /// + /// Returns the maximal elements of the given sequence, based on + /// the given projection and the specified comparer for projected values. + /// + /// + /// This operator uses deferred execution. The results are evaluated + /// and cached on first use to returned sequence. + /// + /// Type of the source sequence + /// Type of the projected element + /// Source sequence + /// Selector to use to pick the results to compare + /// Comparer to use to compare projected values + /// The sequence of maximal elements, according to the projection. + /// , + /// or is null + + public static IExtremaEnumerable Maxima(this IEnumerable source, + Func selector, IComparer? comparer) + => MoreEnumerable.Maxima(source, selector, comparer); + + } + /// MinBy extension. [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")] @@ -3466,6 +3518,8 @@ public static partial class MinByExtension /// The sequence of minimal elements, according to the projection. /// or is null + [Obsolete($"Use {ExtremaMembers.Minima} instead.")] + [ExcludeFromCodeCoverage] public static IExtremaEnumerable MinBy(this IEnumerable source, Func selector) => MoreEnumerable.MinBy(source, selector); @@ -3487,12 +3541,62 @@ public static IExtremaEnumerable MinBy(this IEnumerable< /// , /// or is null + [Obsolete($"Use {nameof(ExtremaMembers.Minima)} instead.")] + [ExcludeFromCodeCoverage] public static IExtremaEnumerable MinBy(this IEnumerable source, Func selector, IComparer? comparer) => MoreEnumerable.MinBy(source, selector, comparer); } + /// Minima extension. + + [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")] + public static partial class MinimaExtension + { + /// + /// Returns the minimal elements of the given sequence, based on + /// the given projection. + /// + /// + /// This overload uses the default comparer for the projected type. + /// This operator uses deferred execution. The results are evaluated + /// and cached on first use to returned sequence. + /// + /// Type of the source sequence + /// Type of the projected element + /// Source sequence + /// Selector to use to pick the results to compare + /// The sequence of minimal elements, according to the projection. + /// or is null + + public static IExtremaEnumerable Minima(this IEnumerable source, + Func selector) + => MoreEnumerable.Minima(source, selector); + + /// + /// Returns the minimal elements of the given sequence, based on + /// the given projection and the specified comparer for projected values. + /// + /// + /// This operator uses deferred execution. The results are evaluated + /// and cached on first use to returned sequence. + /// + /// Type of the source sequence + /// Type of the projected element + /// Source sequence + /// Selector to use to pick the results to compare + /// Comparer to use to compare projected values + /// The sequence of minimal elements, according to the projection. + /// , + /// or is null + + public static IExtremaEnumerable Minima(this IEnumerable source, + Func selector, IComparer? comparer) + => MoreEnumerable.Minima(source, selector, comparer); + + } + /// Move extension. [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")] diff --git a/MoreLinq/ExtremaMembers.cs b/MoreLinq/ExtremaMembers.cs new file mode 100644 index 000000000..b976927b1 --- /dev/null +++ b/MoreLinq/ExtremaMembers.cs @@ -0,0 +1,25 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2023 Atif Aziz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq +{ + static class ExtremaMembers + { + public const string Minima = nameof(MoreEnumerable.Minima); + public const string Maxima = nameof(MoreEnumerable.Maxima); + } +} diff --git a/MoreLinq/MaxBy.cs b/MoreLinq/MaxBy.cs index 919c98fdd..9c105ef5c 100644 --- a/MoreLinq/MaxBy.cs +++ b/MoreLinq/MaxBy.cs @@ -18,157 +18,11 @@ namespace MoreLinq { using System; - using System.Collections; using System.Collections.Generic; - using System.Linq; - - /// - /// Exposes the enumerator, which supports iteration over a sequence of - /// some extremum property (maximum or minimum) of a specified type. - /// - /// The type of objects to enumerate. - - public interface IExtremaEnumerable : IEnumerable - { - /// - /// Returns a specified number of contiguous elements from the start of - /// the sequence. - /// - /// The number of elements to return. - /// - /// An that contains the specified number - /// of elements from the start of the input sequence. - /// - - IEnumerable Take(int count); - - /// - /// Returns a specified number of contiguous elements at the end of the - /// sequence. - /// - /// The number of elements to return. - /// - /// An that contains the specified number - /// of elements at the end of the input sequence. - /// - - IEnumerable TakeLast(int count); - } + using System.Diagnostics.CodeAnalysis; static partial class MoreEnumerable { - /// - /// Returns the first element of a sequence. - /// - /// - /// The type of the elements of . - /// The input sequence. - /// - /// The input sequence is empty. - /// - /// The first element of the input sequence. - /// - - public static T First(this IExtremaEnumerable source) - { - if (source == null) throw new ArgumentNullException(nameof(source)); - return source.Take(1).AsEnumerable().First(); - } - - /// - /// Returns the first element of a sequence, or a default value if the - /// sequence contains no elements. - /// - /// - /// The type of the elements of . - /// The input sequence. - /// - /// Default value of type if source is empty; - /// otherwise, the first element in source. - /// - - public static T? FirstOrDefault(this IExtremaEnumerable source) - { - if (source == null) throw new ArgumentNullException(nameof(source)); - return source.Take(1).AsEnumerable().FirstOrDefault(); - } - - /// - /// Returns the last element of a sequence. - /// - /// - /// The type of the elements of . - /// The input sequence. - /// - /// The input sequence is empty. - /// - /// The last element of the input sequence. - /// - - public static T Last(this IExtremaEnumerable source) - { - if (source == null) throw new ArgumentNullException(nameof(source)); - return source.TakeLast(1).AsEnumerable().Last(); - } - - /// - /// Returns the last element of a sequence, or a default value if the - /// sequence contains no elements. - /// - /// - /// The type of the elements of . - /// The input sequence. - /// - /// Default value of type if source is empty; - /// otherwise, the last element in source. - /// - - public static T? LastOrDefault(this IExtremaEnumerable source) - { - if (source == null) throw new ArgumentNullException(nameof(source)); - return source.TakeLast(1).AsEnumerable().LastOrDefault(); - } - - /// - /// Returns the only element of a sequence, and throws an exception if - /// there is not exactly one element in the sequence. - /// - /// - /// The type of the elements of . - /// The input sequence. - /// - /// The input sequence contains more than one element. - /// - /// The single element of the input sequence. - /// - -#pragma warning disable CA1720 // Identifier contains type name - public static T Single(this IExtremaEnumerable source) -#pragma warning restore CA1720 // Identifier contains type name - { - if (source == null) throw new ArgumentNullException(nameof(source)); - return source.Take(2).AsEnumerable().Single(); - } - - /// - /// Returns the only element of a sequence, or a default value if the - /// sequence is empty; this method throws an exception if there is more - /// than one element in the sequence. - /// - /// - /// The type of the elements of . - /// The input sequence. - /// - /// The single element of the input sequence, or default value of type - /// if the sequence contains no elements. - /// - - public static T? SingleOrDefault(this IExtremaEnumerable source) - { - if (source == null) throw new ArgumentNullException(nameof(source)); - return source.Take(2).AsEnumerable().SingleOrDefault(); - } - /// /// Returns the maximal elements of the given sequence, based on /// the given projection. @@ -185,10 +39,17 @@ public static T Single(this IExtremaEnumerable source) /// The sequence of maximal elements, according to the projection. /// or is null + [Obsolete($"Use {nameof(ExtremaMembers.Maxima)} instead.")] + [ExcludeFromCodeCoverage] +#if !NET6_0_OR_GREATER public static IExtremaEnumerable MaxBy(this IEnumerable source, Func selector) +#else + public static IExtremaEnumerable MaxBy(IEnumerable source, + Func selector) +#endif { - return source.MaxBy(selector, null); + return MaxBy(source, selector, null); } /// @@ -208,161 +69,17 @@ public static IExtremaEnumerable MaxBy(this IEnumerable< /// , /// or is null + [Obsolete($"Use {nameof(ExtremaMembers.Maxima)} instead.")] + [ExcludeFromCodeCoverage] +#if !NET6_0_OR_GREATER public static IExtremaEnumerable MaxBy(this IEnumerable source, Func selector, IComparer? comparer) +#else + public static IExtremaEnumerable MaxBy(IEnumerable source, + Func selector, IComparer? comparer) +#endif { - if (source == null) throw new ArgumentNullException(nameof(source)); - if (selector == null) throw new ArgumentNullException(nameof(selector)); - - comparer ??= Comparer.Default; - return new ExtremaEnumerable(source, selector, comparer.Compare); - } - - sealed class ExtremaEnumerable : IExtremaEnumerable - { - readonly IEnumerable _source; - readonly Func _selector; - readonly Func _comparer; - - public ExtremaEnumerable(IEnumerable source, Func selector, Func comparer) - { - _source = source; - _selector = selector; - _comparer = comparer; - } - - public IEnumerator GetEnumerator() => - ExtremaBy(_source, Extrema.First, null, _selector, _comparer).GetEnumerator(); - - IEnumerator IEnumerable.GetEnumerator() => - GetEnumerator(); - - public IEnumerable Take(int count) => - count switch - { - 0 => Enumerable.Empty(), - 1 => ExtremaBy(_source, Extremum.First, 1 , _selector, _comparer), - _ => ExtremaBy(_source, Extrema.First , count, _selector, _comparer) - }; - - public IEnumerable TakeLast(int count) => - count switch - { - 0 => Enumerable.Empty(), - 1 => ExtremaBy(_source, Extremum.Last, 1 , _selector, _comparer), - _ => ExtremaBy(_source, Extrema.Last , count, _selector, _comparer) - }; - - static class Extrema - { - public static readonly Extrema? , T> First = new FirstExtrema(); - public static readonly Extrema?, T> Last = new LastExtrema(); - - sealed class FirstExtrema : Extrema?, T> - { - public override List? New() => null; - public override void Restart(ref List? store) => store = null; - public override IEnumerable GetEnumerable(List? store) => store ?? Enumerable.Empty(); - - public override void Add(ref List? store, int? limit, T item) - { - if (limit == null || store is null || store.Count < limit) - (store ??= new List()).Add(item); - } - } - - sealed class LastExtrema : Extrema?, T> - { - public override Queue? New() => null; - public override void Restart(ref Queue? store) => store = null; - public override IEnumerable GetEnumerable(Queue? store) => store ?? Enumerable.Empty(); - - public override void Add(ref Queue? store, int? limit, T item) - { - if (limit is { } n && store is { } queue && queue.Count == n) - _ = queue.Dequeue(); - (store ??= new Queue()).Enqueue(item); - } - } - } - - sealed class Extremum : Extrema<(bool, T), T> - { - public static readonly Extrema<(bool, T), T> First = new Extremum(false); - public static readonly Extrema<(bool, T), T> Last = new Extremum(true); - - readonly bool _poppable; - Extremum(bool poppable) => _poppable = poppable; - - public override (bool, T) New() => default; - public override void Restart(ref (bool, T) store) => store = default; - - public override IEnumerable GetEnumerable((bool, T) store) => - store is (true, var item) ? Enumerable.Repeat(item, 1) : Enumerable.Empty(); - - public override void Add(ref (bool, T) store, int? limit, T item) - { - if (!_poppable && store is (true, _)) - return; - store = (true, item); - } - } - } - - // > In mathematical analysis, the maxima and minima (the respective - // > plurals of maximum and minimum) of a function, known collectively - // > as extrema (the plural of extremum), ... - // > - // > - https://en.wikipedia.org/wiki/Maxima_and_minima - - static IEnumerable ExtremaBy( - this IEnumerable source, - Extrema extrema, int? limit, - Func selector, Func comparer) - { - foreach (var item in Extrema()) - yield return item; - - IEnumerable Extrema() - { - using var e = source.GetEnumerator(); - - if (!e.MoveNext()) - return new List(); - - var store = extrema.New(); - extrema.Add(ref store, limit, e.Current); - var extremaKey = selector(e.Current); - - while (e.MoveNext()) - { - var item = e.Current; - var key = selector(item); - switch (comparer(key, extremaKey)) - { - case > 0: - extrema.Restart(ref store); - extrema.Add(ref store, limit, item); - extremaKey = key; - break; - case 0: - extrema.Add(ref store, limit, item); - break; - default: - break; - } - } - - return extrema.GetEnumerable(store); - } - } - - abstract class Extrema - { - public abstract TStore New(); - public abstract void Restart(ref TStore store); - public abstract IEnumerable GetEnumerable(TStore store); - public abstract void Add(ref TStore store, int? limit, T item); + return source.Maxima(selector, comparer); } } } diff --git a/MoreLinq/Maxima.cs b/MoreLinq/Maxima.cs new file mode 100644 index 000000000..60150a433 --- /dev/null +++ b/MoreLinq/Maxima.cs @@ -0,0 +1,368 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2008 Jonathan Skeet. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq +{ + using System; + using System.Collections; + using System.Collections.Generic; + using System.Linq; + + /// + /// Exposes the enumerator, which supports iteration over a sequence of + /// some extremum property (maximum or minimum) of a specified type. + /// + /// The type of objects to enumerate. + + public interface IExtremaEnumerable : IEnumerable + { + /// + /// Returns a specified number of contiguous elements from the start of + /// the sequence. + /// + /// The number of elements to return. + /// + /// An that contains the specified number + /// of elements from the start of the input sequence. + /// + + IEnumerable Take(int count); + + /// + /// Returns a specified number of contiguous elements at the end of the + /// sequence. + /// + /// The number of elements to return. + /// + /// An that contains the specified number + /// of elements at the end of the input sequence. + /// + + IEnumerable TakeLast(int count); + } + + static partial class MoreEnumerable + { + /// + /// Returns the first element of a sequence. + /// + /// + /// The type of the elements of . + /// The input sequence. + /// + /// The input sequence is empty. + /// + /// The first element of the input sequence. + /// + + public static T First(this IExtremaEnumerable source) + { + if (source == null) throw new ArgumentNullException(nameof(source)); + return source.Take(1).AsEnumerable().First(); + } + + /// + /// Returns the first element of a sequence, or a default value if the + /// sequence contains no elements. + /// + /// + /// The type of the elements of . + /// The input sequence. + /// + /// Default value of type if source is empty; + /// otherwise, the first element in source. + /// + + public static T? FirstOrDefault(this IExtremaEnumerable source) + { + if (source == null) throw new ArgumentNullException(nameof(source)); + return source.Take(1).AsEnumerable().FirstOrDefault(); + } + + /// + /// Returns the last element of a sequence. + /// + /// + /// The type of the elements of . + /// The input sequence. + /// + /// The input sequence is empty. + /// + /// The last element of the input sequence. + /// + + public static T Last(this IExtremaEnumerable source) + { + if (source == null) throw new ArgumentNullException(nameof(source)); + return source.TakeLast(1).AsEnumerable().Last(); + } + + /// + /// Returns the last element of a sequence, or a default value if the + /// sequence contains no elements. + /// + /// + /// The type of the elements of . + /// The input sequence. + /// + /// Default value of type if source is empty; + /// otherwise, the last element in source. + /// + + public static T? LastOrDefault(this IExtremaEnumerable source) + { + if (source == null) throw new ArgumentNullException(nameof(source)); + return source.TakeLast(1).AsEnumerable().LastOrDefault(); + } + + /// + /// Returns the only element of a sequence, and throws an exception if + /// there is not exactly one element in the sequence. + /// + /// + /// The type of the elements of . + /// The input sequence. + /// + /// The input sequence contains more than one element. + /// + /// The single element of the input sequence. + /// + +#pragma warning disable CA1720 // Identifier contains type name + public static T Single(this IExtremaEnumerable source) +#pragma warning restore CA1720 // Identifier contains type name + { + if (source == null) throw new ArgumentNullException(nameof(source)); + return source.Take(2).AsEnumerable().Single(); + } + + /// + /// Returns the only element of a sequence, or a default value if the + /// sequence is empty; this method throws an exception if there is more + /// than one element in the sequence. + /// + /// + /// The type of the elements of . + /// The input sequence. + /// + /// The single element of the input sequence, or default value of type + /// if the sequence contains no elements. + /// + + public static T? SingleOrDefault(this IExtremaEnumerable source) + { + if (source == null) throw new ArgumentNullException(nameof(source)); + return source.Take(2).AsEnumerable().SingleOrDefault(); + } + + /// + /// Returns the maximal elements of the given sequence, based on + /// the given projection. + /// + /// + /// This overload uses the default comparer for the projected type. + /// This operator uses deferred execution. The results are evaluated + /// and cached on first use to returned sequence. + /// + /// Type of the source sequence + /// Type of the projected element + /// Source sequence + /// Selector to use to pick the results to compare + /// The sequence of maximal elements, according to the projection. + /// or is null + + public static IExtremaEnumerable Maxima(this IEnumerable source, + Func selector) + { + return source.Maxima(selector, null); + } + + /// + /// Returns the maximal elements of the given sequence, based on + /// the given projection and the specified comparer for projected values. + /// + /// + /// This operator uses deferred execution. The results are evaluated + /// and cached on first use to returned sequence. + /// + /// Type of the source sequence + /// Type of the projected element + /// Source sequence + /// Selector to use to pick the results to compare + /// Comparer to use to compare projected values + /// The sequence of maximal elements, according to the projection. + /// , + /// or is null + + public static IExtremaEnumerable Maxima(this IEnumerable source, + Func selector, IComparer? comparer) + { + if (source == null) throw new ArgumentNullException(nameof(source)); + if (selector == null) throw new ArgumentNullException(nameof(selector)); + + comparer ??= Comparer.Default; + return new ExtremaEnumerable(source, selector, comparer.Compare); + } + + sealed class ExtremaEnumerable : IExtremaEnumerable + { + readonly IEnumerable _source; + readonly Func _selector; + readonly Func _comparer; + + public ExtremaEnumerable(IEnumerable source, Func selector, Func comparer) + { + _source = source; + _selector = selector; + _comparer = comparer; + } + + public IEnumerator GetEnumerator() => + ExtremaBy(_source, Extrema.First, null, _selector, _comparer).GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => + GetEnumerator(); + + public IEnumerable Take(int count) => + count switch + { + 0 => Enumerable.Empty(), + 1 => ExtremaBy(_source, Extremum.First, 1 , _selector, _comparer), + _ => ExtremaBy(_source, Extrema.First , count, _selector, _comparer) + }; + + public IEnumerable TakeLast(int count) => + count switch + { + 0 => Enumerable.Empty(), + 1 => ExtremaBy(_source, Extremum.Last, 1 , _selector, _comparer), + _ => ExtremaBy(_source, Extrema.Last , count, _selector, _comparer) + }; + + static class Extrema + { + public static readonly Extrema? , T> First = new FirstExtrema(); + public static readonly Extrema?, T> Last = new LastExtrema(); + + sealed class FirstExtrema : Extrema?, T> + { + public override List? New() => null; + public override void Restart(ref List? store) => store = null; + public override IEnumerable GetEnumerable(List? store) => store ?? Enumerable.Empty(); + + public override void Add(ref List? store, int? limit, T item) + { + if (limit == null || store is null || store.Count < limit) + (store ??= new List()).Add(item); + } + } + + sealed class LastExtrema : Extrema?, T> + { + public override Queue? New() => null; + public override void Restart(ref Queue? store) => store = null; + public override IEnumerable GetEnumerable(Queue? store) => store ?? Enumerable.Empty(); + + public override void Add(ref Queue? store, int? limit, T item) + { + if (limit is { } n && store is { } queue && queue.Count == n) + _ = queue.Dequeue(); + (store ??= new Queue()).Enqueue(item); + } + } + } + + sealed class Extremum : Extrema<(bool, T), T> + { + public static readonly Extrema<(bool, T), T> First = new Extremum(false); + public static readonly Extrema<(bool, T), T> Last = new Extremum(true); + + readonly bool _poppable; + Extremum(bool poppable) => _poppable = poppable; + + public override (bool, T) New() => default; + public override void Restart(ref (bool, T) store) => store = default; + + public override IEnumerable GetEnumerable((bool, T) store) => + store is (true, var item) ? Enumerable.Repeat(item, 1) : Enumerable.Empty(); + + public override void Add(ref (bool, T) store, int? limit, T item) + { + if (!_poppable && store is (true, _)) + return; + store = (true, item); + } + } + } + + // > In mathematical analysis, the maxima and minima (the respective + // > plurals of maximum and minimum) of a function, known collectively + // > as extrema (the plural of extremum), ... + // > + // > - https://en.wikipedia.org/wiki/Maxima_and_minima + + static IEnumerable ExtremaBy( + this IEnumerable source, + Extrema extrema, int? limit, + Func selector, Func comparer) + { + foreach (var item in Extrema()) + yield return item; + + IEnumerable Extrema() + { + using var e = source.GetEnumerator(); + + if (!e.MoveNext()) + return new List(); + + var store = extrema.New(); + extrema.Add(ref store, limit, e.Current); + var extremaKey = selector(e.Current); + + while (e.MoveNext()) + { + var item = e.Current; + var key = selector(item); + switch (comparer(key, extremaKey)) + { + case > 0: + extrema.Restart(ref store); + extrema.Add(ref store, limit, item); + extremaKey = key; + break; + case 0: + extrema.Add(ref store, limit, item); + break; + default: + break; + } + } + + return extrema.GetEnumerable(store); + } + } + + abstract class Extrema + { + public abstract TStore New(); + public abstract void Restart(ref TStore store); + public abstract IEnumerable GetEnumerable(TStore store); + public abstract void Add(ref TStore store, int? limit, T item); + } + } +} diff --git a/MoreLinq/MinBy.cs b/MoreLinq/MinBy.cs index 625d698df..54773b8ef 100644 --- a/MoreLinq/MinBy.cs +++ b/MoreLinq/MinBy.cs @@ -19,6 +19,7 @@ namespace MoreLinq { using System; using System.Collections.Generic; + using System.Diagnostics.CodeAnalysis; static partial class MoreEnumerable { @@ -38,10 +39,17 @@ static partial class MoreEnumerable /// The sequence of minimal elements, according to the projection. /// or is null + [Obsolete($"Use {ExtremaMembers.Minima} instead.")] + [ExcludeFromCodeCoverage] +#if !NET6_0_OR_GREATER public static IExtremaEnumerable MinBy(this IEnumerable source, Func selector) +#else + public static IExtremaEnumerable MinBy(IEnumerable source, + Func selector) +#endif { - return source.MinBy(selector, null); + return MinBy(source, selector, null); } /// @@ -61,14 +69,17 @@ public static IExtremaEnumerable MinBy(this IEnumerable< /// , /// or is null + [Obsolete($"Use {nameof(ExtremaMembers.Minima)} instead.")] + [ExcludeFromCodeCoverage] +#if !NET6_0_OR_GREATER public static IExtremaEnumerable MinBy(this IEnumerable source, Func selector, IComparer? comparer) +#else + public static IExtremaEnumerable MinBy(IEnumerable source, + Func selector, IComparer? comparer) +#endif { - if (source == null) throw new ArgumentNullException(nameof(source)); - if (selector == null) throw new ArgumentNullException(nameof(selector)); - - comparer ??= Comparer.Default; - return new ExtremaEnumerable(source, selector, (x, y) => -Math.Sign(comparer.Compare(x, y))); + return source.Minima(selector, comparer); } } } diff --git a/MoreLinq/Minima.cs b/MoreLinq/Minima.cs new file mode 100644 index 000000000..ba9f584e7 --- /dev/null +++ b/MoreLinq/Minima.cs @@ -0,0 +1,74 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2008 Jonathan Skeet. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq +{ + using System; + using System.Collections.Generic; + + static partial class MoreEnumerable + { + /// + /// Returns the minimal elements of the given sequence, based on + /// the given projection. + /// + /// + /// This overload uses the default comparer for the projected type. + /// This operator uses deferred execution. The results are evaluated + /// and cached on first use to returned sequence. + /// + /// Type of the source sequence + /// Type of the projected element + /// Source sequence + /// Selector to use to pick the results to compare + /// The sequence of minimal elements, according to the projection. + /// or is null + + public static IExtremaEnumerable Minima(this IEnumerable source, + Func selector) + { + return source.Minima(selector, null); + } + + /// + /// Returns the minimal elements of the given sequence, based on + /// the given projection and the specified comparer for projected values. + /// + /// + /// This operator uses deferred execution. The results are evaluated + /// and cached on first use to returned sequence. + /// + /// Type of the source sequence + /// Type of the projected element + /// Source sequence + /// Selector to use to pick the results to compare + /// Comparer to use to compare projected values + /// The sequence of minimal elements, according to the projection. + /// , + /// or is null + + public static IExtremaEnumerable Minima(this IEnumerable source, + Func selector, IComparer? comparer) + { + if (source == null) throw new ArgumentNullException(nameof(source)); + if (selector == null) throw new ArgumentNullException(nameof(selector)); + + comparer ??= Comparer.Default; + return new ExtremaEnumerable(source, selector, (x, y) => -Math.Sign(comparer.Compare(x, y))); + } + } +} diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 4397916e4..f46e55965 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -52,10 +52,10 @@ - Lag - Lead - LeftJoin - - MaxBy + - Maxima - Memoize (EXPERIMENTAL) - Merge (EXPERIMENTAL) - - MinBy + - Minima - Move - OrderBy - OrderedMerge diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt index c2a9e629e..8b26bf00b 100644 --- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt @@ -8,18 +8,36 @@ *REMOVED*static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +*REMOVED*static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! *REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! *REMOVED*static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +MoreLinq.Extensions.MaximaExtension +MoreLinq.Extensions.MinimaExtension static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt index fa0a2a28d..baeef302c 100644 --- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt @@ -7,9 +7,19 @@ *REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! *REMOVED*static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +MoreLinq.Extensions.MaximaExtension +MoreLinq.Extensions.MinimaExtension static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt index 85be22323..0a76e35e0 100644 --- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt @@ -11,11 +11,21 @@ *REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! *REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! *REMOVED*static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +MoreLinq.Extensions.MaximaExtension +MoreLinq.Extensions.MinimaExtension static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! diff --git a/README.md b/README.md index de6b4e622..ac9da48de 100644 --- a/README.md +++ b/README.md @@ -361,14 +361,32 @@ Performs a left outer join between two sequences. This method has 4 overloads. -### MaxBy +### ~~MaxBy~~ + +:warning: **This method is obsolete. Use [`Maxima`](#maxima) instead.** + +Returns the maxima (maximal elements) of the given sequence, based on the +given projection. + +This method has 2 overloads. + +### Maxima Returns the maxima (maximal elements) of the given sequence, based on the given projection. This method has 2 overloads. -### MinBy +### ~~MinBy~~ + +:warning: **This method is obsolete. Use [`Maxima`](#maxima) instead.** + +Returns the minima (minimal elements) of the given sequence, based on the +given projection. + +This method has 2 overloads. + +### Minima Returns the minima (minimal elements) of the given sequence, based on the given projection. diff --git a/bld/ExtensionsGenerator/Program.cs b/bld/ExtensionsGenerator/Program.cs index 87dba483d..762eae7e7 100644 --- a/bld/ExtensionsGenerator/Program.cs +++ b/bld/ExtensionsGenerator/Program.cs @@ -120,7 +120,6 @@ from md in cd.DescendantNodes().OfType() where md.ParameterList.Parameters.Count > 0 && md.ParameterList.Parameters.First().Modifiers.Any(m => m.Value is "this") && md.Modifiers.Any(m => m.Value is "public") - && md.AttributeLists.SelectMany(al => al.Attributes).All(a => a.Name.ToString() != "Obsolete") // // Build a dictionary of type abbreviations (e.g. TSource -> a, // TResult -> b, etc.) for the method's type parameters. If the From 17c6201082c8a0979d13a44035cfcd8df83a8652 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Wed, 25 Oct 2023 22:00:12 +0200 Subject: [PATCH 112/157] Remove redundant IsExternalInit package --- MoreLinq.Test/MoreLinq.Test.csproj | 4 ---- 1 file changed, 4 deletions(-) diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index 97e4d7bc2..8eff0287b 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -22,10 +22,6 @@ all - - runtime; build; native; contentfiles; analyzers; buildtransitive - all - runtime; build; native; contentfiles; analyzers all From 91d3996df623934cf5a666bd34a4b039056aaa98 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Wed, 25 Oct 2023 22:51:27 +0200 Subject: [PATCH 113/157] Update all packages to latest versions --- MoreLinq.Test/.editorconfig | 6 ++++++ MoreLinq.Test/MoreLinq.Test.csproj | 14 +++++++------- MoreLinq/MoreLinq.csproj | 2 +- .../MoreLinq.ExtensionsGenerator.csproj | 2 +- 4 files changed, 15 insertions(+), 9 deletions(-) diff --git a/MoreLinq.Test/.editorconfig b/MoreLinq.Test/.editorconfig index d9548d45a..ffc9fb911 100644 --- a/MoreLinq.Test/.editorconfig +++ b/MoreLinq.Test/.editorconfig @@ -37,3 +37,9 @@ dotnet_diagnostic.IDE0047.severity = suggestion # IDE0022: Use expression/block body for methods dotnet_diagnostic.IDE0022.severity = none + +# NUnit1030: The type of parameter provided by the TestCaseSource does not match the type of the parameter in the Test method +dotnet_diagnostic.NUnit1030.severity = suggestion + +# Nunit1029: The number of parameters provided by the TestCaseSource does not match the number of parameters in the Test method +dotnet_diagnostic.NUnit1029.severity = suggestion diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index 8eff0287b..77e2b5cbc 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -17,7 +17,7 @@ - + runtime; build; native; contentfiles; analyzers; buildtransitive all @@ -27,23 +27,23 @@ all - + all runtime; build; native; contentfiles; analyzers; buildtransitive - + all runtime; build; native; contentfiles; analyzers; buildtransitive - + - - + + - + diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index f46e55965..10a1bbd24 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -161,7 +161,7 @@ all - + diff --git a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj index 9e19b8bfb..e810d01e0 100644 --- a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj +++ b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj @@ -6,7 +6,7 @@ - + From c01e64649860ac8f49c539b893c982095acbadb9 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Wed, 25 Oct 2023 23:44:48 +0200 Subject: [PATCH 114/157] Fix "MinBy" successor in read-me doc --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index ac9da48de..98d40de8a 100644 --- a/README.md +++ b/README.md @@ -379,7 +379,7 @@ This method has 2 overloads. ### ~~MinBy~~ -:warning: **This method is obsolete. Use [`Maxima`](#maxima) instead.** +:warning: **This method is obsolete. Use [`Minima`](#minima) instead.** Returns the minima (minimal elements) of the given sequence, based on the given projection. From 2c3f004c4be8562c4f7be1377d4ef7a25c5aec2f Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 26 Oct 2023 21:11:24 +0200 Subject: [PATCH 115/157] List required PolySharp polyfills explicitly --- MoreLinq/MoreLinq.csproj | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 10a1bbd24..4ed9e868b 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -164,6 +164,18 @@ + + + System.Index; + System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute; + System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute; + System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute; + System.Diagnostics.CodeAnalysis.MemberNotNullAttribute; + System.Diagnostics.CodeAnalysis.NotNullWhenAttribute; + System.Runtime.CompilerServices.CallerArgumentExpressionAttribute; + + + From 02098976df09e8bdd9e9acb45c401071ee91d68c Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 28 Oct 2023 15:20:43 +0200 Subject: [PATCH 116/157] Don't validate content of "Interleave" arg This is a squashed merge of PR #1031 that fixes #1029. --- MoreLinq.Test/InterleaveTest.cs | 14 -------------- MoreLinq/Interleave.cs | 2 -- 2 files changed, 16 deletions(-) diff --git a/MoreLinq.Test/InterleaveTest.cs b/MoreLinq.Test/InterleaveTest.cs index 84db32566..5d6384d8e 100644 --- a/MoreLinq.Test/InterleaveTest.cs +++ b/MoreLinq.Test/InterleaveTest.cs @@ -50,20 +50,6 @@ public void TestInterleaveDisposesOnErrorAtGetEnumerator() Throws.BreakException); } - /// - /// Verify that Interleave early throw ArgumentNullException when an element - /// of otherSequences is null. - /// - [Test] - public void TestInterleaveEarlyThrowOnNullElementInOtherSequences() - { - var sequenceA = Enumerable.Range(1, 1); - var otherSequences = new IEnumerable[] { null! }; - - Assert.That(() => sequenceA.Interleave(otherSequences), - Throws.ArgumentNullException("otherSequences")); - } - /// /// Verify that interleaving disposes those enumerators that it managed /// to open successfully diff --git a/MoreLinq/Interleave.cs b/MoreLinq/Interleave.cs index c053341d5..501a8f667 100644 --- a/MoreLinq/Interleave.cs +++ b/MoreLinq/Interleave.cs @@ -54,8 +54,6 @@ public static IEnumerable Interleave(this IEnumerable sequence, params { if (sequence == null) throw new ArgumentNullException(nameof(sequence)); if (otherSequences == null) throw new ArgumentNullException(nameof(otherSequences)); - if (otherSequences.Any(s => s == null)) - throw new ArgumentNullException(nameof(otherSequences), "One or more sequences passed to Interleave was null."); return Impl(otherSequences.Prepend(sequence)); From 092a40d82a1b280568ffa006d9a210bdec0792cd Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 28 Oct 2023 15:53:05 +0200 Subject: [PATCH 117/157] Fix exception thrown for invalid "Pad"/"PadStart" width This is a squashed merge of PR #1030 that: - fixes #1027 - fixes #1028 --- MoreLinq.Test/PadStartTest.cs | 35 ++++++++++++++++------------------- MoreLinq.Test/PadTest.cs | 19 ++++++++++++++++--- MoreLinq/Pad.cs | 4 ++-- MoreLinq/PadStart.cs | 4 ++-- 4 files changed, 36 insertions(+), 26 deletions(-) diff --git a/MoreLinq.Test/PadStartTest.cs b/MoreLinq.Test/PadStartTest.cs index 78d45ef4d..5e84f6e3d 100644 --- a/MoreLinq.Test/PadStartTest.cs +++ b/MoreLinq.Test/PadStartTest.cs @@ -17,21 +17,32 @@ namespace MoreLinq.Test { - using NUnit.Framework; using System; using System.Collections.Generic; + using NUnit.Framework; + using NUnit.Framework.Interfaces; [TestFixture] public class PadStartTest { - // PadStart(source, width) + static readonly IEnumerable PadStartWithNegativeWidthCases = + from e in new (string Name, TestDelegate Delegate)[] + { + ("DefaultPadding" , static () => new object[0].PadStart(-1)), + ("Padding" , static () => new object[0].PadStart(-1, -2)), + ("PaddingSelector", static () => new object[0].PadStart(-1, BreakingFunc.Of())), + } + select new TestCaseData(e.Delegate).SetName(e.Name); - [Test] - public void PadStartWithNegativeWidth() + [TestCaseSource(nameof(PadStartWithNegativeWidthCases))] + public void PadStartWithNegativeWidth(TestDelegate @delegate) { - Assert.That(() => new int[0].PadStart(-1), Throws.ArgumentException("width")); + Assert.That(@delegate, Throws.ArgumentOutOfRangeException("width") + .And.Property(nameof(ArgumentOutOfRangeException.ActualValue)).EqualTo(-1)); } + // PadStart(source, width) + [Test] public void PadStartIsLazy() { @@ -61,12 +72,6 @@ public void ReferenceTypeElements(ICollection source, int width, IEnume // PadStart(source, width, padding) - [Test] - public void PadStartWithPaddingWithNegativeWidth() - { - Assert.That(() => new int[0].PadStart(-1, 1), Throws.ArgumentException("width")); - } - [Test] public void PadStartWithPaddingIsLazy() { @@ -94,14 +99,6 @@ public void ReferenceTypeElements(ICollection source, int width, IEnumer } } - // PadStart(source, width, paddingSelector) - - [Test] - public void PadStartWithSelectorWithNegativeWidth() - { - Assert.That(() => new int[0].PadStart(-1, x => x), Throws.ArgumentException("width")); - } - [Test] public void PadStartWithSelectorIsLazy() { diff --git a/MoreLinq.Test/PadTest.cs b/MoreLinq.Test/PadTest.cs index cbe323d28..9a1f61949 100644 --- a/MoreLinq.Test/PadTest.cs +++ b/MoreLinq.Test/PadTest.cs @@ -17,15 +17,28 @@ namespace MoreLinq.Test { + using System; + using System.Collections.Generic; using NUnit.Framework; + using NUnit.Framework.Interfaces; [TestFixture] public class PadTest { - [Test] - public void PadNegativeWidth() + static readonly IEnumerable PadNegativeWidthCases = + from e in new (string Name, TestDelegate Delegate)[] + { + ("DefaultPadding" , static () => new object[0].Pad(-1)), + ("Padding" , static () => new object[0].Pad(-1, -2)), + ("PaddingSelector", static () => new object[0].Pad(-1, BreakingFunc.Of())), + } + select new TestCaseData(e.Delegate).SetName(e.Name); + + [TestCaseSource(nameof(PadNegativeWidthCases))] + public void PadNegativeWidth(TestDelegate @delegate) { - Assert.That(() => new object[0].Pad(-1), Throws.ArgumentException("width")); + Assert.That(@delegate, Throws.ArgumentOutOfRangeException("width") + .And.Property(nameof(ArgumentOutOfRangeException.ActualValue)).EqualTo(-1)); } [Test] diff --git a/MoreLinq/Pad.cs b/MoreLinq/Pad.cs index 9fc728c35..eeb4dda77 100644 --- a/MoreLinq/Pad.cs +++ b/MoreLinq/Pad.cs @@ -77,7 +77,7 @@ static partial class MoreEnumerable public static IEnumerable Pad(this IEnumerable source, int width, TSource padding) { if (source == null) throw new ArgumentNullException(nameof(source)); - if (width < 0) throw new ArgumentException(null, nameof(width)); + if (width < 0) throw new ArgumentOutOfRangeException(nameof(width), width, null); return PadImpl(source, width, padding, null); } @@ -109,7 +109,7 @@ public static IEnumerable Pad(this IEnumerable source { if (source == null) throw new ArgumentNullException(nameof(source)); if (paddingSelector == null) throw new ArgumentNullException(nameof(paddingSelector)); - if (width < 0) throw new ArgumentException(null, nameof(width)); + if (width < 0) throw new ArgumentOutOfRangeException(nameof(width), width, null); return PadImpl(source, width, default, paddingSelector); } diff --git a/MoreLinq/PadStart.cs b/MoreLinq/PadStart.cs index 2979da6b3..5e9e380d1 100644 --- a/MoreLinq/PadStart.cs +++ b/MoreLinq/PadStart.cs @@ -76,7 +76,7 @@ static partial class MoreEnumerable public static IEnumerable PadStart(this IEnumerable source, int width, TSource padding) { if (source == null) throw new ArgumentNullException(nameof(source)); - if (width < 0) throw new ArgumentException(null, nameof(width)); + if (width < 0) throw new ArgumentOutOfRangeException(nameof(width), width, null); return PadStartImpl(source, width, padding, null); } @@ -110,7 +110,7 @@ public static IEnumerable PadStart(this IEnumerable s { if (source == null) throw new ArgumentNullException(nameof(source)); if (paddingSelector == null) throw new ArgumentNullException(nameof(paddingSelector)); - if (width < 0) throw new ArgumentException(null, nameof(width)); + if (width < 0) throw new ArgumentOutOfRangeException(nameof(width), width, null); return PadStartImpl(source, width, default, paddingSelector); } From 48cb8513eeb304726838a9a72166df28cc937c4e Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 29 Oct 2023 22:40:23 +0100 Subject: [PATCH 118/157] Remove obsolete CI skip commits file list --- appveyor.yml | 6 ------ 1 file changed, 6 deletions(-) diff --git a/appveyor.yml b/appveyor.yml index 1a8636fe8..27d35a0ad 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -41,12 +41,6 @@ for: - image: macos-bigsur environment: IMAGE_NAME: macos -skip_commits: - files: - - '*.md' - - '*.txt' - - '.editorconfig' - - lic/* install: - npm install -g eclint - git rm .editorconfig From 0a38ee4c3a9dbfa0163a775b4a636c2c62857ddf Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 9 Nov 2023 08:03:05 +0100 Subject: [PATCH 119/157] Update .NET install scripts - https://dot.net/v1/dotnet-install.ps1 - https://dot.net/v1/dotnet-install.sh --- tools/dotnet-install.ps1 | 582 ++++++++++++++++++++++----------------- tools/dotnet-install.sh | 138 ++++++++-- 2 files changed, 442 insertions(+), 278 deletions(-) diff --git a/tools/dotnet-install.ps1 b/tools/dotnet-install.ps1 index 3821006a3..f4ae4c673 100644 --- a/tools/dotnet-install.ps1 +++ b/tools/dotnet-install.ps1 @@ -9,6 +9,12 @@ .DESCRIPTION Installs dotnet cli. If dotnet installation already exists in the given directory it will update it only if the requested version differs from the one already installed. + + Note that the intended use of this script is for Continuous Integration (CI) scenarios, where: + - The SDK needs to be installed without user interaction and without admin rights. + - The SDK installation doesn't need to persist across multiple CI runs. + To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer. + .PARAMETER Channel Default: LTS Download from the Channel specified. Possible values: @@ -23,10 +29,10 @@ Note: The version parameter overrides the channel parameter when any version other than 'latest' is used. .PARAMETER Quality Download the latest build of specified quality in the channel. The possible values are: daily, signed, validated, preview, GA. - Works only in combination with channel. Not applicable for STS and LTS channels and will be ignored if those channels are used. + Works only in combination with channel. Not applicable for STS and LTS channels and will be ignored if those channels are used. For SDK use channel in A.B.Cxx format: using quality together with channel in A.B format is not supported. Supported since 5.0 release. - Note: The version parameter overrides the channel parameter when any version other than 'latest' is used, and therefore overrides the quality. + Note: The version parameter overrides the channel parameter when any version other than 'latest' is used, and therefore overrides the quality. .PARAMETER Version Default: latest Represents a build version on specific channel. Possible values: @@ -92,6 +98,10 @@ .PARAMETER DownloadTimeout Determines timeout duration in seconds for dowloading of the SDK file Default: 1200 seconds (20 minutes) +.PARAMETER KeepZip + If set, downloaded file is kept +.PARAMETER ZipPath + Use that path to store installer, generated by default #> [cmdletbinding()] param( @@ -115,7 +125,9 @@ param( [string[]]$ProxyBypassList=@(), [switch]$SkipNonVersionedFiles, [switch]$NoCdn, - [int]$DownloadTimeout=1200 + [int]$DownloadTimeout=1200, + [switch]$KeepZip, + [string]$ZipPath=[System.IO.Path]::combine([System.IO.Path]::GetTempPath(), [System.IO.Path]::GetRandomFileName()) ) Set-StrictMode -Version Latest @@ -164,6 +176,29 @@ function Say-Verbose($str) { } } +function Measure-Action($name, $block) { + $time = Measure-Command $block + $totalSeconds = $time.TotalSeconds + Say-Verbose "⏱ Action '$name' took $totalSeconds seconds" +} + +function Get-Remote-File-Size($zipUri) { + try { + $response = Invoke-WebRequest -Uri $zipUri -Method Head + $fileSize = $response.Headers["Content-Length"] + if ((![string]::IsNullOrEmpty($fileSize))) { + Say "Remote file $zipUri size is $fileSize bytes." + + return $fileSize + } + } + catch { + Say-Verbose "Content-Length header was not extracted for $zipUri." + } + + return $null +} + function Say-Invocation($Invocation) { $command = $Invocation.MyCommand; $args = (($Invocation.BoundParameters.Keys | foreach { "-$_ `"$($Invocation.BoundParameters[$_])`"" }) -join " ") @@ -205,12 +240,12 @@ function Get-Machine-Architecture() { return $ENV:PROCESSOR_ARCHITEW6432 } - try { + try { if( ((Get-CimInstance -ClassName CIM_OperatingSystem).OSArchitecture) -like "ARM*") { if( [Environment]::Is64BitOperatingSystem ) { return "arm64" - } + } return "arm" } } @@ -247,7 +282,7 @@ function ValidateFeedCredential([string] $FeedCredential) throw "$message" } } - + #FeedCredential should start with "?", for it to be added to the end of the link. #adding "?" at the beginning of the FeedCredential if needed. if ((![string]::IsNullOrWhitespace($FeedCredential)) -and ($FeedCredential[0] -ne '?')) { @@ -374,7 +409,7 @@ function GetHTTPResponse([Uri] $Uri, [bool]$HeaderOnly, [bool]$DisableRedirect, UseDefaultCredentials=$ProxyUseDefaultCredentials; BypassList = $ProxyBypassList; } - } + } if ($DisableRedirect) { $HttpClientHandler.AllowAutoRedirect = $false @@ -548,7 +583,7 @@ function Get-Specific-Version-From-Version([string]$AzureFeed, [string]$Channel, return $LatestVersionInfo.Version } else { - return $Version + return $Version } } else { @@ -616,7 +651,7 @@ function Get-Product-Version([string]$AzureFeed, [string]$SpecificVersion, [stri # Try to get the version number, using the productVersion.txt file located next to the installer file. $ProductVersionTxtURLs = (Get-Product-Version-Url $AzureFeed $SpecificVersion $PackageDownloadLink -Flattened $true), (Get-Product-Version-Url $AzureFeed $SpecificVersion $PackageDownloadLink -Flattened $false) - + Foreach ($ProductVersionTxtURL in $ProductVersionTxtURLs) { Say-Verbose "Checking for the existence of $ProductVersionTxtURL" @@ -634,7 +669,7 @@ function Get-Product-Version([string]$AzureFeed, [string]$SpecificVersion, [stri else { Say-Verbose "Got StatusCode $($productVersionResponse.StatusCode) when trying to get productVersion.txt at $productVersionTxtUrl." } - } + } catch { Say-Verbose "Could not read productVersion.txt at $productVersionTxtUrl (Exception: '$($_.Exception.Message)'. )" } @@ -719,7 +754,7 @@ function Get-ProductVersionFromDownloadLink([string]$PackageDownloadLink, [strin Say-Verbose "Using the default value '$SpecificVersion' as the product version." $productVersion = $SpecificVersion } - return $productVersion + return $productVersion } function Get-User-Share-Path() { @@ -850,13 +885,15 @@ function DownloadFile($Source, [string]$OutPath) { } $Stream = $null - + try { $Response = GetHTTPResponse -Uri $Source $Stream = $Response.Content.ReadAsStreamAsync().Result $File = [System.IO.File]::Create($OutPath) $Stream.CopyTo($File) $File.Close() + + ValidateRemoteLocalFileSizes -LocalFileOutPath $OutPath -SourceUri $Source } finally { if ($null -ne $Stream) { @@ -865,19 +902,40 @@ function DownloadFile($Source, [string]$OutPath) { } } +function ValidateRemoteLocalFileSizes([string]$LocalFileOutPath, $SourceUri) { + try { + $remoteFileSize = Get-Remote-File-Size -zipUri $SourceUri + $fileSize = [long](Get-Item $LocalFileOutPath).Length + Say "Downloaded file $SourceUri size is $fileSize bytes." + + if ((![string]::IsNullOrEmpty($remoteFileSize)) -and !([string]::IsNullOrEmpty($fileSize)) ) { + if ($remoteFileSize -ne $fileSize) { + Say "The remote and local file sizes are not equal. Remote file size is $remoteFileSize bytes and local size is $fileSize bytes. The local package may be corrupted." + } + else { + Say "The remote and local file sizes are equal." + } + } + else { + Say "Either downloaded or local package size can not be measured. One of them may be corrupted." + } + } + catch { + Say "Either downloaded or local package size can not be measured. One of them may be corrupted." + } +} + function SafeRemoveFile($Path) { try { if (Test-Path $Path) { Remove-Item $Path Say-Verbose "The temporary file `"$Path`" was removed." } - else - { + else { Say-Verbose "The temporary file `"$Path`" does not exist, therefore is not removed." } } - catch - { + catch { Say-Warning "Failed to remove the temporary file: `"$Path`", remove it manually." } } @@ -901,7 +959,7 @@ function Prepend-Sdk-InstallRoot-To-Path([string]$InstallRoot) { function PrintDryRunOutput($Invocation, $DownloadLinks) { Say "Payload URLs:" - + for ($linkIndex=0; $linkIndex -lt $DownloadLinks.count; $linkIndex++) { Say "URL #$linkIndex - $($DownloadLinks[$linkIndex].type): $($DownloadLinks[$linkIndex].downloadLink)" } @@ -929,15 +987,15 @@ function PrintDryRunOutput($Invocation, $DownloadLinks) } function Get-AkaMSDownloadLink([string]$Channel, [string]$Quality, [bool]$Internal, [string]$Product, [string]$Architecture) { - Say-Invocation $MyInvocation + Say-Invocation $MyInvocation #quality is not supported for LTS or STS channel if (![string]::IsNullOrEmpty($Quality) -and (@("LTS", "STS") -contains $Channel)) { $Quality = "" Say-Warning "Specifying quality for STS or LTS channel is not supported, the quality will be ignored." } - Say-Verbose "Retrieving primary payload URL from aka.ms link for channel: '$Channel', quality: '$Quality' product: '$Product', os: 'win', architecture: '$Architecture'." - + Say-Verbose "Retrieving primary payload URL from aka.ms link for channel: '$Channel', quality: '$Quality' product: '$Product', os: 'win', architecture: '$Architecture'." + #construct aka.ms link $akaMsLink = "https://aka.ms/dotnet" if ($Internal) { @@ -1003,7 +1061,7 @@ function Get-AkaMSDownloadLink([string]$Channel, [string]$Quality, [bool]$Intern function Get-AkaMsLink-And-Version([string] $NormalizedChannel, [string] $NormalizedQuality, [bool] $Internal, [string] $ProductName, [string] $Architecture) { $AkaMsDownloadLink = Get-AkaMSDownloadLink -Channel $NormalizedChannel -Quality $NormalizedQuality -Internal $Internal -Product $ProductName -Architecture $Architecture - + if ([string]::IsNullOrEmpty($AkaMsDownloadLink)){ if (-not [string]::IsNullOrEmpty($NormalizedQuality)) { # if quality is specified - exit with error - there is no fallback approach @@ -1020,7 +1078,7 @@ function Get-AkaMsLink-And-Version([string] $NormalizedChannel, [string] $Normal #get version from the path $pathParts = $AkaMsDownloadLink.Split('/') - if ($pathParts.Length -ge 2) { + if ($pathParts.Length -ge 2) { $SpecificVersion = $pathParts[$pathParts.Length - 2] Say-Verbose "Version: '$SpecificVersion'." } @@ -1063,7 +1121,7 @@ function Get-Feeds-To-Use() } function Resolve-AssetName-And-RelativePath([string] $Runtime) { - + if ($Runtime -eq "dotnet") { $assetName = ".NET Core Runtime" $dotnetPackageRelativePath = "shared\Microsoft.NETCore.App" @@ -1088,26 +1146,34 @@ function Resolve-AssetName-And-RelativePath([string] $Runtime) { } function Prepare-Install-Directory { + $diskSpaceWarning = "Failed to check the disk space. Installation will continue, but it may fail if you do not have enough disk space."; + + if ($PSVersionTable.PSVersion.Major -lt 7) { + Say-Verbose $diskSpaceWarning + return + } + New-Item -ItemType Directory -Force -Path $InstallRoot | Out-Null $installDrive = $((Get-Item $InstallRoot -Force).PSDrive.Name); $diskInfo = $null - try{ + try { $diskInfo = Get-PSDrive -Name $installDrive } - catch{ - Say-Warning "Failed to check the disk space. Installation will continue, but it may fail if you do not have enough disk space." + catch { + Say-Warning $diskSpaceWarning } + # The check is relevant for PS version >= 7, the result can be irrelevant for older versions. See https://github.com/PowerShell/PowerShell/issues/12442. if ( ($null -ne $diskInfo) -and ($diskInfo.Free / 1MB -le 100)) { throw "There is not enough disk space on drive ${installDrive}:" } } -Say "Note that the intended use of this script is for Continuous Integration (CI) scenarios, where:" -Say "- The SDK needs to be installed without user interaction and without admin rights." -Say "- The SDK installation doesn't need to persist across multiple CI runs." -Say "To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer.`r`n" +Say-Verbose "Note that the intended use of this script is for Continuous Integration (CI) scenarios, where:" +Say-Verbose "- The SDK needs to be installed without user interaction and without admin rights." +Say-Verbose "- The SDK installation doesn't need to persist across multiple CI runs." +Say-Verbose "To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer.`r`n" if ($SharedRuntime -and (-not $Runtime)) { $Runtime = "dotnet" @@ -1115,14 +1181,16 @@ if ($SharedRuntime -and (-not $Runtime)) { $OverrideNonVersionedFiles = !$SkipNonVersionedFiles -$CLIArchitecture = Get-CLIArchitecture-From-Architecture $Architecture -$NormalizedQuality = Get-NormalizedQuality $Quality -Say-Verbose "Normalized quality: '$NormalizedQuality'" -$NormalizedChannel = Get-NormalizedChannel $Channel -Say-Verbose "Normalized channel: '$NormalizedChannel'" -$NormalizedProduct = Get-NormalizedProduct $Runtime -Say-Verbose "Normalized product: '$NormalizedProduct'" -$FeedCredential = ValidateFeedCredential $FeedCredential +Measure-Action "Product discovery" { + $script:CLIArchitecture = Get-CLIArchitecture-From-Architecture $Architecture + $script:NormalizedQuality = Get-NormalizedQuality $Quality + Say-Verbose "Normalized quality: '$NormalizedQuality'" + $script:NormalizedChannel = Get-NormalizedChannel $Channel + Say-Verbose "Normalized channel: '$NormalizedChannel'" + $script:NormalizedProduct = Get-NormalizedProduct $Runtime + Say-Verbose "Normalized product: '$NormalizedProduct'" + $script:FeedCredential = ValidateFeedCredential $FeedCredential +} $InstallRoot = Resolve-Installation-Path $InstallDir Say-Verbose "InstallRoot: $InstallRoot" @@ -1139,11 +1207,11 @@ if ($Version.ToLowerInvariant() -ne "latest" -and -not [string]::IsNullOrEmpty($ # aka.ms links can only be used if the user did not request a specific version via the command line or a global.json file. if ([string]::IsNullOrEmpty($JSonFile) -and ($Version -eq "latest")) { ($DownloadLink, $SpecificVersion, $EffectiveVersion) = Get-AkaMsLink-And-Version $NormalizedChannel $NormalizedQuality $Internal $NormalizedProduct $CLIArchitecture - + if ($null -ne $DownloadLink) { $DownloadLinks += New-Object PSObject -Property @{downloadLink="$DownloadLink";specificVersion="$SpecificVersion";effectiveVersion="$EffectiveVersion";type='aka.ms'} Say-Verbose "Generated aka.ms link $DownloadLink with version $EffectiveVersion" - + if (-Not $DryRun) { Say-Verbose "Checking if the version $EffectiveVersion is already installed" if (Is-Dotnet-Package-Installed -InstallRoot $InstallRoot -RelativePathToPackage $dotnetPackageRelativePath -SpecificVersion $EffectiveVersion) @@ -1165,15 +1233,15 @@ if ([string]::IsNullOrEmpty($NormalizedQuality) -and 0 -eq $DownloadLinks.count) $SpecificVersion = Get-Specific-Version-From-Version -AzureFeed $feed -Channel $Channel -Version $Version -JSonFile $JSonFile $DownloadLink, $EffectiveVersion = Get-Download-Link -AzureFeed $feed -SpecificVersion $SpecificVersion -CLIArchitecture $CLIArchitecture $LegacyDownloadLink = Get-LegacyDownload-Link -AzureFeed $feed -SpecificVersion $SpecificVersion -CLIArchitecture $CLIArchitecture - + $DownloadLinks += New-Object PSObject -Property @{downloadLink="$DownloadLink";specificVersion="$SpecificVersion";effectiveVersion="$EffectiveVersion";type='primary'} Say-Verbose "Generated primary link $DownloadLink with version $EffectiveVersion" - + if (-not [string]::IsNullOrEmpty($LegacyDownloadLink)) { $DownloadLinks += New-Object PSObject -Property @{downloadLink="$LegacyDownloadLink";specificVersion="$SpecificVersion";effectiveVersion="$EffectiveVersion";type='legacy'} Say-Verbose "Generated legacy link $LegacyDownloadLink with version $EffectiveVersion" } - + if (-Not $DryRun) { Say-Verbose "Checking if the version $EffectiveVersion is already installed" if (Is-Dotnet-Package-Installed -InstallRoot $InstallRoot -RelativePathToPackage $dotnetPackageRelativePath -SpecificVersion $EffectiveVersion) @@ -1200,9 +1268,8 @@ if ($DryRun) { return } -Prepare-Install-Directory +Measure-Action "Installation directory preparation" { Prepare-Install-Directory } -$ZipPath = [System.IO.Path]::combine([System.IO.Path]::GetTempPath(), [System.IO.Path]::GetRandomFileName()) Say-Verbose "Zip path: $ZipPath" $DownloadSucceeded = $false @@ -1214,7 +1281,7 @@ foreach ($link in $DownloadLinks) Say-Verbose "Downloading `"$($link.type)`" link $($link.downloadLink)" try { - DownloadFile -Source $link.downloadLink -OutPath $ZipPath + Measure-Action "Package download" { DownloadFile -Source $link.downloadLink -OutPath $ZipPath } Say-Verbose "Download succeeded." $DownloadSucceeded = $true $DownloadedLink = $link @@ -1227,7 +1294,7 @@ foreach ($link in $DownloadLinks) if ($PSItem.Exception.Data.Contains("StatusCode")) { $StatusCode = $PSItem.Exception.Data["StatusCode"] } - + if ($PSItem.Exception.Data.Contains("ErrorMessage")) { $ErrorMessage = $PSItem.Exception.Data["ErrorMessage"] } else { @@ -1251,7 +1318,7 @@ if (-not $DownloadSucceeded) { } Say "Extracting the archive." -Extract-Dotnet-Package -ZipPath $ZipPath -OutPath $InstallRoot +Measure-Action "Package extraction" { Extract-Dotnet-Package -ZipPath $ZipPath -OutPath $InstallRoot } # Check if the SDK version is installed; if not, fail the installation. $isAssetInstalled = $false @@ -1275,227 +1342,228 @@ if (!$isAssetInstalled) { throw "`"$assetName`" with version = $($DownloadedLink.effectiveVersion) failed to install with an unknown error." } -SafeRemoveFile -Path $ZipPath +if (-not $KeepZip) { + SafeRemoveFile -Path $ZipPath +} -Prepend-Sdk-InstallRoot-To-Path -InstallRoot $InstallRoot +Measure-Action "Setting up shell environment" { Prepend-Sdk-InstallRoot-To-Path -InstallRoot $InstallRoot } Say "Note that the script does not resolve dependencies during installation." Say "To check the list of dependencies, go to https://learn.microsoft.com/dotnet/core/install/windows#dependencies" Say "Installed version is $($DownloadedLink.effectiveVersion)" Say "Installation finished" - # SIG # Begin signature block -# MIInzgYJKoZIhvcNAQcCoIInvzCCJ7sCAQExDzANBglghkgBZQMEAgEFADB5Bgor +# MIInvwYJKoZIhvcNAQcCoIInsDCCJ6wCAQExDzANBglghkgBZQMEAgEFADB5Bgor # BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG -# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCB7pzZ0nuEMd30h -# n1EcAYUQN+1clltqaLf9611TDrw/laCCDYUwggYDMIID66ADAgECAhMzAAACzfNk -# v/jUTF1RAAAAAALNMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD +# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCACRu+yvG+6rftW +# 7639o2K9YFU32HKgY4Dqe9C3db/p7qCCDXYwggX0MIID3KADAgECAhMzAAADTrU8 +# esGEb+srAAAAAANOMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD # VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy # b3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25p -# bmcgUENBIDIwMTEwHhcNMjIwNTEyMjA0NjAyWhcNMjMwNTExMjA0NjAyWjB0MQsw +# bmcgUENBIDIwMTEwHhcNMjMwMzE2MTg0MzI5WhcNMjQwMzE0MTg0MzI5WjB0MQsw # CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u # ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMR4wHAYDVQQDExVNaWNy # b3NvZnQgQ29ycG9yYXRpb24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB -# AQDrIzsY62MmKrzergm7Ucnu+DuSHdgzRZVCIGi9CalFrhwtiK+3FIDzlOYbs/zz -# HwuLC3hir55wVgHoaC4liQwQ60wVyR17EZPa4BQ28C5ARlxqftdp3H8RrXWbVyvQ -# aUnBQVZM73XDyGV1oUPZGHGWtgdqtBUd60VjnFPICSf8pnFiit6hvSxH5IVWI0iO -# nfqdXYoPWUtVUMmVqW1yBX0NtbQlSHIU6hlPvo9/uqKvkjFUFA2LbC9AWQbJmH+1 -# uM0l4nDSKfCqccvdI5l3zjEk9yUSUmh1IQhDFn+5SL2JmnCF0jZEZ4f5HE7ykDP+ -# oiA3Q+fhKCseg+0aEHi+DRPZAgMBAAGjggGCMIIBfjAfBgNVHSUEGDAWBgorBgEE -# AYI3TAgBBggrBgEFBQcDAzAdBgNVHQ4EFgQU0WymH4CP7s1+yQktEwbcLQuR9Zww -# VAYDVR0RBE0wS6RJMEcxLTArBgNVBAsTJE1pY3Jvc29mdCBJcmVsYW5kIE9wZXJh -# dGlvbnMgTGltaXRlZDEWMBQGA1UEBRMNMjMwMDEyKzQ3MDUzMDAfBgNVHSMEGDAW -# gBRIbmTlUAXTgqoXNzcitW2oynUClTBUBgNVHR8ETTBLMEmgR6BFhkNodHRwOi8v -# d3d3Lm1pY3Jvc29mdC5jb20vcGtpb3BzL2NybC9NaWNDb2RTaWdQQ0EyMDExXzIw -# MTEtMDctMDguY3JsMGEGCCsGAQUFBwEBBFUwUzBRBggrBgEFBQcwAoZFaHR0cDov -# L3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9jZXJ0cy9NaWNDb2RTaWdQQ0EyMDEx -# XzIwMTEtMDctMDguY3J0MAwGA1UdEwEB/wQCMAAwDQYJKoZIhvcNAQELBQADggIB -# AE7LSuuNObCBWYuttxJAgilXJ92GpyV/fTiyXHZ/9LbzXs/MfKnPwRydlmA2ak0r -# GWLDFh89zAWHFI8t9JLwpd/VRoVE3+WyzTIskdbBnHbf1yjo/+0tpHlnroFJdcDS -# MIsH+T7z3ClY+6WnjSTetpg1Y/pLOLXZpZjYeXQiFwo9G5lzUcSd8YVQNPQAGICl -# 2JRSaCNlzAdIFCF5PNKoXbJtEqDcPZ8oDrM9KdO7TqUE5VqeBe6DggY1sZYnQD+/ -# LWlz5D0wCriNgGQ/TWWexMwwnEqlIwfkIcNFxo0QND/6Ya9DTAUykk2SKGSPt0kL -# tHxNEn2GJvcNtfohVY/b0tuyF05eXE3cdtYZbeGoU1xQixPZAlTdtLmeFNly82uB -# VbybAZ4Ut18F//UrugVQ9UUdK1uYmc+2SdRQQCccKwXGOuYgZ1ULW2u5PyfWxzo4 -# BR++53OB/tZXQpz4OkgBZeqs9YaYLFfKRlQHVtmQghFHzB5v/WFonxDVlvPxy2go -# a0u9Z+ZlIpvooZRvm6OtXxdAjMBcWBAsnBRr/Oj5s356EDdf2l/sLwLFYE61t+ME -# iNYdy0pXL6gN3DxTVf2qjJxXFkFfjjTisndudHsguEMk8mEtnvwo9fOSKT6oRHhM -# 9sZ4HTg/TTMjUljmN3mBYWAWI5ExdC1inuog0xrKmOWVMIIHejCCBWKgAwIBAgIK -# YQ6Q0gAAAAAAAzANBgkqhkiG9w0BAQsFADCBiDELMAkGA1UEBhMCVVMxEzARBgNV -# BAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jv -# c29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlm -# aWNhdGUgQXV0aG9yaXR5IDIwMTEwHhcNMTEwNzA4MjA1OTA5WhcNMjYwNzA4MjEw -# OTA5WjB+MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UE -# BxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSgwJgYD -# VQQDEx9NaWNyb3NvZnQgQ29kZSBTaWduaW5nIFBDQSAyMDExMIICIjANBgkqhkiG -# 9w0BAQEFAAOCAg8AMIICCgKCAgEAq/D6chAcLq3YbqqCEE00uvK2WCGfQhsqa+la -# UKq4BjgaBEm6f8MMHt03a8YS2AvwOMKZBrDIOdUBFDFC04kNeWSHfpRgJGyvnkmc -# 6Whe0t+bU7IKLMOv2akrrnoJr9eWWcpgGgXpZnboMlImEi/nqwhQz7NEt13YxC4D -# dato88tt8zpcoRb0RrrgOGSsbmQ1eKagYw8t00CT+OPeBw3VXHmlSSnnDb6gE3e+ -# lD3v++MrWhAfTVYoonpy4BI6t0le2O3tQ5GD2Xuye4Yb2T6xjF3oiU+EGvKhL1nk -# kDstrjNYxbc+/jLTswM9sbKvkjh+0p2ALPVOVpEhNSXDOW5kf1O6nA+tGSOEy/S6 -# A4aN91/w0FK/jJSHvMAhdCVfGCi2zCcoOCWYOUo2z3yxkq4cI6epZuxhH2rhKEmd -# X4jiJV3TIUs+UsS1Vz8kA/DRelsv1SPjcF0PUUZ3s/gA4bysAoJf28AVs70b1FVL -# 5zmhD+kjSbwYuER8ReTBw3J64HLnJN+/RpnF78IcV9uDjexNSTCnq47f7Fufr/zd -# sGbiwZeBe+3W7UvnSSmnEyimp31ngOaKYnhfsi+E11ecXL93KCjx7W3DKI8sj0A3 -# T8HhhUSJxAlMxdSlQy90lfdu+HggWCwTXWCVmj5PM4TasIgX3p5O9JawvEagbJjS -# 4NaIjAsCAwEAAaOCAe0wggHpMBAGCSsGAQQBgjcVAQQDAgEAMB0GA1UdDgQWBBRI -# bmTlUAXTgqoXNzcitW2oynUClTAZBgkrBgEEAYI3FAIEDB4KAFMAdQBiAEMAQTAL -# BgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAfBgNVHSMEGDAWgBRyLToCMZBD -# uRQFTuHqp8cx0SOJNDBaBgNVHR8EUzBRME+gTaBLhklodHRwOi8vY3JsLm1pY3Jv -# c29mdC5jb20vcGtpL2NybC9wcm9kdWN0cy9NaWNSb29DZXJBdXQyMDExXzIwMTFf -# MDNfMjIuY3JsMF4GCCsGAQUFBwEBBFIwUDBOBggrBgEFBQcwAoZCaHR0cDovL3d3 -# dy5taWNyb3NvZnQuY29tL3BraS9jZXJ0cy9NaWNSb29DZXJBdXQyMDExXzIwMTFf -# MDNfMjIuY3J0MIGfBgNVHSAEgZcwgZQwgZEGCSsGAQQBgjcuAzCBgzA/BggrBgEF -# BQcCARYzaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9kb2NzL3ByaW1h -# cnljcHMuaHRtMEAGCCsGAQUFBwICMDQeMiAdAEwAZQBnAGEAbABfAHAAbwBsAGkA -# YwB5AF8AcwB0AGEAdABlAG0AZQBuAHQALiAdMA0GCSqGSIb3DQEBCwUAA4ICAQBn -# 8oalmOBUeRou09h0ZyKbC5YR4WOSmUKWfdJ5DJDBZV8uLD74w3LRbYP+vj/oCso7 -# v0epo/Np22O/IjWll11lhJB9i0ZQVdgMknzSGksc8zxCi1LQsP1r4z4HLimb5j0b -# pdS1HXeUOeLpZMlEPXh6I/MTfaaQdION9MsmAkYqwooQu6SpBQyb7Wj6aC6VoCo/ -# KmtYSWMfCWluWpiW5IP0wI/zRive/DvQvTXvbiWu5a8n7dDd8w6vmSiXmE0OPQvy -# CInWH8MyGOLwxS3OW560STkKxgrCxq2u5bLZ2xWIUUVYODJxJxp/sfQn+N4sOiBp -# mLJZiWhub6e3dMNABQamASooPoI/E01mC8CzTfXhj38cbxV9Rad25UAqZaPDXVJi -# hsMdYzaXht/a8/jyFqGaJ+HNpZfQ7l1jQeNbB5yHPgZ3BtEGsXUfFL5hYbXw3MYb -# BL7fQccOKO7eZS/sl/ahXJbYANahRr1Z85elCUtIEJmAH9AAKcWxm6U/RXceNcbS -# oqKfenoi+kiVH6v7RyOA9Z74v2u3S5fi63V4GuzqN5l5GEv/1rMjaHXmr/r8i+sL -# gOppO6/8MO0ETI7f33VtY5E90Z1WTk+/gFcioXgRMiF670EKsT/7qMykXcGhiJtX -# cVZOSEXAQsmbdlsKgEhr/Xmfwb1tbWrJUnMTDXpQzTGCGZ8wghmbAgEBMIGVMH4x -# CzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRt -# b25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01p -# Y3Jvc29mdCBDb2RlIFNpZ25pbmcgUENBIDIwMTECEzMAAALN82S/+NRMXVEAAAAA -# As0wDQYJYIZIAWUDBAIBBQCgga4wGQYJKoZIhvcNAQkDMQwGCisGAQQBgjcCAQQw -# HAYKKwYBBAGCNwIBCzEOMAwGCisGAQQBgjcCARUwLwYJKoZIhvcNAQkEMSIEINK7 -# cJe0KVfbcXchjID30U/cUg7pWAQUa3+n8JuhjLCLMEIGCisGAQQBgjcCAQwxNDAy -# oBSAEgBNAGkAYwByAG8AcwBvAGYAdKEagBhodHRwOi8vd3d3Lm1pY3Jvc29mdC5j -# b20wDQYJKoZIhvcNAQEBBQAEggEAODLxcflOtjpIXXIhbYyQ0wFeBx0NrmoMU/Ri -# e7CRrAieAbG4iLJzs4DhUov5iuMHY6AAbLWAH54QlSkd4XNp6POsE7lSzN9yjlVw -# V/e0XCaYeXIbtd75hGd5P7wAhM4m2ViDI4IRHyQtjysW0U0F6YiqNlFm7Fzo5Si6 -# l2XxvuEDSdyJcEN70wHQajx6bKfnI/oMY59iGjDXvDP/6cQV9NI0gPHFTwPKA7vg -# PySyVFEG7dQMoEwAWy9GHbcS//RulgUwBhWcrtUP411XLSO6is2VTknwbdglc9HZ -# zViuS4C1ujHlPrlMzm8Y5iGVIQCna5w2NU/kGsSK5+dMkovomKGCFykwghclBgor -# BgEEAYI3AwMBMYIXFTCCFxEGCSqGSIb3DQEHAqCCFwIwghb+AgEDMQ8wDQYJYIZI -# AWUDBAIBBQAwggFZBgsqhkiG9w0BCRABBKCCAUgEggFEMIIBQAIBAQYKKwYBBAGE -# WQoDATAxMA0GCWCGSAFlAwQCAQUABCDRz6ce9oWlH6+o0BtjmAjtvEMN1hfhIA5v -# +wTZHvB4XgIGY2PeyIloGBMyMDIyMTExMDE1MDUxNi43MzRaMASAAgH0oIHYpIHV -# MIHSMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMH -# UmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMS0wKwYDVQQL -# EyRNaWNyb3NvZnQgSXJlbGFuZCBPcGVyYXRpb25zIExpbWl0ZWQxJjAkBgNVBAsT -# HVRoYWxlcyBUU1MgRVNOOkEyNDAtNEI4Mi0xMzBFMSUwIwYDVQQDExxNaWNyb3Nv -# ZnQgVGltZS1TdGFtcCBTZXJ2aWNloIIReDCCBycwggUPoAMCAQICEzMAAAG4CNTB -# uHngUUkAAQAAAbgwDQYJKoZIhvcNAQELBQAwfDELMAkGA1UEBhMCVVMxEzARBgNV +# AQDdCKiNI6IBFWuvJUmf6WdOJqZmIwYs5G7AJD5UbcL6tsC+EBPDbr36pFGo1bsU +# p53nRyFYnncoMg8FK0d8jLlw0lgexDDr7gicf2zOBFWqfv/nSLwzJFNP5W03DF/1 +# 1oZ12rSFqGlm+O46cRjTDFBpMRCZZGddZlRBjivby0eI1VgTD1TvAdfBYQe82fhm +# WQkYR/lWmAK+vW/1+bO7jHaxXTNCxLIBW07F8PBjUcwFxxyfbe2mHB4h1L4U0Ofa +# +HX/aREQ7SqYZz59sXM2ySOfvYyIjnqSO80NGBaz5DvzIG88J0+BNhOu2jl6Dfcq +# jYQs1H/PMSQIK6E7lXDXSpXzAgMBAAGjggFzMIIBbzAfBgNVHSUEGDAWBgorBgEE +# AYI3TAgBBggrBgEFBQcDAzAdBgNVHQ4EFgQUnMc7Zn/ukKBsBiWkwdNfsN5pdwAw +# RQYDVR0RBD4wPKQ6MDgxHjAcBgNVBAsTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEW +# MBQGA1UEBRMNMjMwMDEyKzUwMDUxNjAfBgNVHSMEGDAWgBRIbmTlUAXTgqoXNzci +# tW2oynUClTBUBgNVHR8ETTBLMEmgR6BFhkNodHRwOi8vd3d3Lm1pY3Jvc29mdC5j +# b20vcGtpb3BzL2NybC9NaWNDb2RTaWdQQ0EyMDExXzIwMTEtMDctMDguY3JsMGEG +# CCsGAQUFBwEBBFUwUzBRBggrBgEFBQcwAoZFaHR0cDovL3d3dy5taWNyb3NvZnQu +# Y29tL3BraW9wcy9jZXJ0cy9NaWNDb2RTaWdQQ0EyMDExXzIwMTEtMDctMDguY3J0 +# MAwGA1UdEwEB/wQCMAAwDQYJKoZIhvcNAQELBQADggIBAD21v9pHoLdBSNlFAjmk +# mx4XxOZAPsVxxXbDyQv1+kGDe9XpgBnT1lXnx7JDpFMKBwAyIwdInmvhK9pGBa31 +# TyeL3p7R2s0L8SABPPRJHAEk4NHpBXxHjm4TKjezAbSqqbgsy10Y7KApy+9UrKa2 +# kGmsuASsk95PVm5vem7OmTs42vm0BJUU+JPQLg8Y/sdj3TtSfLYYZAaJwTAIgi7d +# hzn5hatLo7Dhz+4T+MrFd+6LUa2U3zr97QwzDthx+RP9/RZnur4inzSQsG5DCVIM +# pA1l2NWEA3KAca0tI2l6hQNYsaKL1kefdfHCrPxEry8onJjyGGv9YKoLv6AOO7Oh +# JEmbQlz/xksYG2N/JSOJ+QqYpGTEuYFYVWain7He6jgb41JbpOGKDdE/b+V2q/gX +# UgFe2gdwTpCDsvh8SMRoq1/BNXcr7iTAU38Vgr83iVtPYmFhZOVM0ULp/kKTVoir +# IpP2KCxT4OekOctt8grYnhJ16QMjmMv5o53hjNFXOxigkQWYzUO+6w50g0FAeFa8 +# 5ugCCB6lXEk21FFB1FdIHpjSQf+LP/W2OV/HfhC3uTPgKbRtXo83TZYEudooyZ/A +# Vu08sibZ3MkGOJORLERNwKm2G7oqdOv4Qj8Z0JrGgMzj46NFKAxkLSpE5oHQYP1H +# tPx1lPfD7iNSbJsP6LiUHXH1MIIHejCCBWKgAwIBAgIKYQ6Q0gAAAAAAAzANBgkq +# hkiG9w0BAQsFADCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24x +# EDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlv +# bjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5 +# IDIwMTEwHhcNMTEwNzA4MjA1OTA5WhcNMjYwNzA4MjEwOTA5WjB+MQswCQYDVQQG +# EwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwG +# A1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSgwJgYDVQQDEx9NaWNyb3NvZnQg +# Q29kZSBTaWduaW5nIFBDQSAyMDExMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC +# CgKCAgEAq/D6chAcLq3YbqqCEE00uvK2WCGfQhsqa+laUKq4BjgaBEm6f8MMHt03 +# a8YS2AvwOMKZBrDIOdUBFDFC04kNeWSHfpRgJGyvnkmc6Whe0t+bU7IKLMOv2akr +# rnoJr9eWWcpgGgXpZnboMlImEi/nqwhQz7NEt13YxC4Ddato88tt8zpcoRb0Rrrg +# OGSsbmQ1eKagYw8t00CT+OPeBw3VXHmlSSnnDb6gE3e+lD3v++MrWhAfTVYoonpy +# 4BI6t0le2O3tQ5GD2Xuye4Yb2T6xjF3oiU+EGvKhL1nkkDstrjNYxbc+/jLTswM9 +# sbKvkjh+0p2ALPVOVpEhNSXDOW5kf1O6nA+tGSOEy/S6A4aN91/w0FK/jJSHvMAh +# dCVfGCi2zCcoOCWYOUo2z3yxkq4cI6epZuxhH2rhKEmdX4jiJV3TIUs+UsS1Vz8k +# A/DRelsv1SPjcF0PUUZ3s/gA4bysAoJf28AVs70b1FVL5zmhD+kjSbwYuER8ReTB +# w3J64HLnJN+/RpnF78IcV9uDjexNSTCnq47f7Fufr/zdsGbiwZeBe+3W7UvnSSmn +# Eyimp31ngOaKYnhfsi+E11ecXL93KCjx7W3DKI8sj0A3T8HhhUSJxAlMxdSlQy90 +# lfdu+HggWCwTXWCVmj5PM4TasIgX3p5O9JawvEagbJjS4NaIjAsCAwEAAaOCAe0w +# ggHpMBAGCSsGAQQBgjcVAQQDAgEAMB0GA1UdDgQWBBRIbmTlUAXTgqoXNzcitW2o +# ynUClTAZBgkrBgEEAYI3FAIEDB4KAFMAdQBiAEMAQTALBgNVHQ8EBAMCAYYwDwYD +# VR0TAQH/BAUwAwEB/zAfBgNVHSMEGDAWgBRyLToCMZBDuRQFTuHqp8cx0SOJNDBa +# BgNVHR8EUzBRME+gTaBLhklodHRwOi8vY3JsLm1pY3Jvc29mdC5jb20vcGtpL2Ny +# bC9wcm9kdWN0cy9NaWNSb29DZXJBdXQyMDExXzIwMTFfMDNfMjIuY3JsMF4GCCsG +# AQUFBwEBBFIwUDBOBggrBgEFBQcwAoZCaHR0cDovL3d3dy5taWNyb3NvZnQuY29t +# L3BraS9jZXJ0cy9NaWNSb29DZXJBdXQyMDExXzIwMTFfMDNfMjIuY3J0MIGfBgNV +# HSAEgZcwgZQwgZEGCSsGAQQBgjcuAzCBgzA/BggrBgEFBQcCARYzaHR0cDovL3d3 +# dy5taWNyb3NvZnQuY29tL3BraW9wcy9kb2NzL3ByaW1hcnljcHMuaHRtMEAGCCsG +# AQUFBwICMDQeMiAdAEwAZQBnAGEAbABfAHAAbwBsAGkAYwB5AF8AcwB0AGEAdABl +# AG0AZQBuAHQALiAdMA0GCSqGSIb3DQEBCwUAA4ICAQBn8oalmOBUeRou09h0ZyKb +# C5YR4WOSmUKWfdJ5DJDBZV8uLD74w3LRbYP+vj/oCso7v0epo/Np22O/IjWll11l +# hJB9i0ZQVdgMknzSGksc8zxCi1LQsP1r4z4HLimb5j0bpdS1HXeUOeLpZMlEPXh6 +# I/MTfaaQdION9MsmAkYqwooQu6SpBQyb7Wj6aC6VoCo/KmtYSWMfCWluWpiW5IP0 +# wI/zRive/DvQvTXvbiWu5a8n7dDd8w6vmSiXmE0OPQvyCInWH8MyGOLwxS3OW560 +# STkKxgrCxq2u5bLZ2xWIUUVYODJxJxp/sfQn+N4sOiBpmLJZiWhub6e3dMNABQam +# ASooPoI/E01mC8CzTfXhj38cbxV9Rad25UAqZaPDXVJihsMdYzaXht/a8/jyFqGa +# J+HNpZfQ7l1jQeNbB5yHPgZ3BtEGsXUfFL5hYbXw3MYbBL7fQccOKO7eZS/sl/ah +# XJbYANahRr1Z85elCUtIEJmAH9AAKcWxm6U/RXceNcbSoqKfenoi+kiVH6v7RyOA +# 9Z74v2u3S5fi63V4GuzqN5l5GEv/1rMjaHXmr/r8i+sLgOppO6/8MO0ETI7f33Vt +# Y5E90Z1WTk+/gFcioXgRMiF670EKsT/7qMykXcGhiJtXcVZOSEXAQsmbdlsKgEhr +# /Xmfwb1tbWrJUnMTDXpQzTGCGZ8wghmbAgEBMIGVMH4xCzAJBgNVBAYTAlVTMRMw +# EQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVN +# aWNyb3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNp +# Z25pbmcgUENBIDIwMTECEzMAAANOtTx6wYRv6ysAAAAAA04wDQYJYIZIAWUDBAIB +# BQCgga4wGQYJKoZIhvcNAQkDMQwGCisGAQQBgjcCAQQwHAYKKwYBBAGCNwIBCzEO +# MAwGCisGAQQBgjcCARUwLwYJKoZIhvcNAQkEMSIEIPHo6D4ixtuX2mtmXYtzP7Xh +# 5SbbHtBt9hwIKfR9nNCHMEIGCisGAQQBgjcCAQwxNDAyoBSAEgBNAGkAYwByAG8A +# cwBvAGYAdKEagBhodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20wDQYJKoZIhvcNAQEB +# BQAEggEAKaYy0/f2nIWjmd2w2g7hU/pz6ahK3cIahIejHpTW8JXUR3neUB9oFm8x +# GiAtgKY6zzxKsMGRJfULOEB+jV8y1TK5aAUtNWog8o7i9hl/W3JLsRtcduGhqvR8 +# oYFq4xkYPDwAjklDN96cWNqWmqsUULs/jxx4Ef0o9/2Cy9FWYwvyDK/o0bdfotsl +# +cr3Aj1fIOSkrMKjEoScITOvfGCDgNqVsu+62itzX0QvIq7yW8aqJ5xd2r94IOry +# u6iMdQFYSxR7xpIaDjKLHCH8tTmKAlrFFekhaxe1WuTvNBt154Zl1U7ukSO12s1N +# ezHYEW4AoLd4MO9zmXwDZmo3RLzFHKGCFykwghclBgorBgEEAYI3AwMBMYIXFTCC +# FxEGCSqGSIb3DQEHAqCCFwIwghb+AgEDMQ8wDQYJYIZIAWUDBAIBBQAwggFZBgsq +# hkiG9w0BCRABBKCCAUgEggFEMIIBQAIBAQYKKwYBBAGEWQoDATAxMA0GCWCGSAFl +# AwQCAQUABCCiX6fcUDSacytCBP6o92QnwRIQCE6w6Se15jgm1UebNAIGZN/N9Z2v +# GBMyMDIzMDkxODEwMDUxOS4zMjJaMASAAgH0oIHYpIHVMIHSMQswCQYDVQQGEwJV +# UzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UE +# ChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMS0wKwYDVQQLEyRNaWNyb3NvZnQgSXJl +# bGFuZCBPcGVyYXRpb25zIExpbWl0ZWQxJjAkBgNVBAsTHVRoYWxlcyBUU1MgRVNO +# OkQwODItNEJGRC1FRUJBMSUwIwYDVQQDExxNaWNyb3NvZnQgVGltZS1TdGFtcCBT +# ZXJ2aWNloIIReDCCBycwggUPoAMCAQICEzMAAAG6Hz8Z98F1vXwAAQAAAbowDQYJ +# KoZIhvcNAQELBQAwfDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24x +# EDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlv +# bjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAgUENBIDIwMTAwHhcNMjIw +# OTIwMjAyMjE5WhcNMjMxMjE0MjAyMjE5WjCB0jELMAkGA1UEBhMCVVMxEzARBgNV # BAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jv -# c29mdCBDb3Jwb3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAg -# UENBIDIwMTAwHhcNMjIwOTIwMjAyMjE2WhcNMjMxMjE0MjAyMjE2WjCB0jELMAkG -# A1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQx -# HjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEtMCsGA1UECxMkTWljcm9z -# b2Z0IElyZWxhbmQgT3BlcmF0aW9ucyBMaW1pdGVkMSYwJAYDVQQLEx1UaGFsZXMg -# VFNTIEVTTjpBMjQwLTRCODItMTMwRTElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUt -# U3RhbXAgU2VydmljZTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAJwb -# sfwRHERn5C95QPGn37tJ5vOiY9aWjeIDxpgaXaYGiqsw0G0cvCK3YulrqemEf2Ck -# GSdcOJAF++EqhOSqrO13nGcjqw6hFNnsGwKANyzddwnOO0jz1lfBIIu77TbfNvna -# WbwSRu0DTGHA7n7PR0MYJ9bC/HopStpbFf606LKcTWnwaUuEdAhx6FAqg1rkgugi -# uuaaxKyxRkdjFZLKFXEXL9p01PtwS0fG6vZiRVnEKgeal2TeLvdAIqapBwltPYif -# gqnp7Z4VJMcPo0TWmRNVFOcHRNwWHehN9xg6ugIGXPo7hMpWrPgg4moHO2epc0T3 -# 6rgm9hlDrl28bG5TakmV7NJ98kbF5lgtlrowT6ecwEVtuLd4a0gzYqhanW7zaFZn -# Dft5yMexy59ifETdzpwArj2nJAyIsiq1PY3XPm2mUMLlACksqelHKfWihK/Fehw/ -# mziovBVwkkr/G0F19OWgR+MBUKifwpOyQiLAxrqvVnfCY4QjJCZiHIuS15HCQ/TI -# t/Qj4x1WvRa1UqjnmpLu4/yBYWZsdvZoq8SXI7iOs7muecAJeEkYlM6iOkMighzE -# hjQK9ThPpoAtluXbL7qIHGrfFlHmX/4soc7jj1j8uB31U34gJlB2XphjMaT+E+O9 -# SImk/6GRV9Sm8C88Fnmm2VdwMluCNAUzPFjfvHx3AgMBAAGjggFJMIIBRTAdBgNV -# HQ4EFgQUxP1HJTeFwzNYo1njfucXuUfQaW4wHwYDVR0jBBgwFoAUn6cVXQBeYl2D -# 9OXSZacbUzUZ6XIwXwYDVR0fBFgwVjBUoFKgUIZOaHR0cDovL3d3dy5taWNyb3Nv -# ZnQuY29tL3BraW9wcy9jcmwvTWljcm9zb2Z0JTIwVGltZS1TdGFtcCUyMFBDQSUy -# MDIwMTAoMSkuY3JsMGwGCCsGAQUFBwEBBGAwXjBcBggrBgEFBQcwAoZQaHR0cDov -# L3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9jZXJ0cy9NaWNyb3NvZnQlMjBUaW1l -# LVN0YW1wJTIwUENBJTIwMjAxMCgxKS5jcnQwDAYDVR0TAQH/BAIwADAWBgNVHSUB -# Af8EDDAKBggrBgEFBQcDCDAOBgNVHQ8BAf8EBAMCB4AwDQYJKoZIhvcNAQELBQAD -# ggIBAJ9uk8miwpMoKw3D996piEzbegAGxkABHYn2vP2hbqnkS9U97s/6QlyZOhGF -# sVudaiLeRZZTsaG5hR0oCuBINZ/lelo5xzHc+mBOpBXpxSaW1hqoxaCLsVH1EBtz -# 7in25Hjy+ejuBcilH6EZ0ZtNxmWGIQz8R0AuS0Tj4VgJXHIlXP9dVOiyGo9Velrk -# +FGx/BC+iEuCaKd/IsypHPiCUCh52DGc91s2S7ldQx1H4CljOAtanDfbvSejASWL -# o/s3w0XMAbDurWNns0XidAF2RnL1PaxoOyz9VYakNGK4F3/uJRZnVgbsCYuwNX1B -# mSwM1ZbPSnggNSGTZx/FQ20Jj/ulrK0ryAbvNbNb4kkaS4a767ifCqvUOFLlUT8P -# N43hhldxI6yHPMOWItJpEHIZBiTNKblBsYbIrghb1Ym9tfSsLa5ZJDzVZNndRfhU -# qJOyXF+CVm9OtVmFDG9kIwM6QAX8Q0if721z4VOzZNvD8ktg1lI+XjXgXDJVs3h4 -# 7sMu9GXSYzky+7dtgmc3iRPkda3YVRdmPJtNFN0NLybcssE7vhFCij75eDGQBFq0 -# A4KVG6uBdr6UTWwE0VKHxBz2BpGvn7BCs+5yxnF+HV6CUickDqqPi/II7Zssd9Eb -# P9uzj4luldXDAPrWGtdGq+wK0odlGNVuCMxsL3hn8+KiO9UiMIIHcTCCBVmgAwIB -# AgITMwAAABXF52ueAptJmQAAAAAAFTANBgkqhkiG9w0BAQsFADCBiDELMAkGA1UE -# BhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAc -# BgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0 -# IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIwMTAwHhcNMjEwOTMwMTgyMjI1 -# WhcNMzAwOTMwMTgzMjI1WjB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGlu -# Z3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBv -# cmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMDCC -# AiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAOThpkzntHIhC3miy9ckeb0O -# 1YLT/e6cBwfSqWxOdcjKNVf2AX9sSuDivbk+F2Az/1xPx2b3lVNxWuJ+Slr+uDZn -# hUYjDLWNE893MsAQGOhgfWpSg0S3po5GawcU88V29YZQ3MFEyHFcUTE3oAo4bo3t -# 1w/YJlN8OWECesSq/XJprx2rrPY2vjUmZNqYO7oaezOtgFt+jBAcnVL+tuhiJdxq -# D89d9P6OU8/W7IVWTe/dvI2k45GPsjksUZzpcGkNyjYtcI4xyDUoveO0hyTD4MmP -# frVUj9z6BVWYbWg7mka97aSueik3rMvrg0XnRm7KMtXAhjBcTyziYrLNueKNiOSW -# rAFKu75xqRdbZ2De+JKRHh09/SDPc31BmkZ1zcRfNN0Sidb9pSB9fvzZnkXftnIv -# 231fgLrbqn427DZM9ituqBJR6L8FA6PRc6ZNN3SUHDSCD/AQ8rdHGO2n6Jl8P0zb -# r17C89XYcz1DTsEzOUyOArxCaC4Q6oRRRuLRvWoYWmEBc8pnol7XKHYC4jMYcten -# IPDC+hIK12NvDMk2ZItboKaDIV1fMHSRlJTYuVD5C4lh8zYGNRiER9vcG9H9stQc -# xWv2XFJRXRLbJbqvUAV6bMURHXLvjflSxIUXk8A8FdsaN8cIFRg/eKtFtvUeh17a -# j54WcmnGrnu3tz5q4i6tAgMBAAGjggHdMIIB2TASBgkrBgEEAYI3FQEEBQIDAQAB -# MCMGCSsGAQQBgjcVAgQWBBQqp1L+ZMSavoKRPEY1Kc8Q/y8E7jAdBgNVHQ4EFgQU -# n6cVXQBeYl2D9OXSZacbUzUZ6XIwXAYDVR0gBFUwUzBRBgwrBgEEAYI3TIN9AQEw -# QTA/BggrBgEFBQcCARYzaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9E -# b2NzL1JlcG9zaXRvcnkuaHRtMBMGA1UdJQQMMAoGCCsGAQUFBwMIMBkGCSsGAQQB -# gjcUAgQMHgoAUwB1AGIAQwBBMAsGA1UdDwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/ -# MB8GA1UdIwQYMBaAFNX2VsuP6KJcYmjRPZSQW9fOmhjEMFYGA1UdHwRPME0wS6BJ -# oEeGRWh0dHA6Ly9jcmwubWljcm9zb2Z0LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01p -# Y1Jvb0NlckF1dF8yMDEwLTA2LTIzLmNybDBaBggrBgEFBQcBAQROMEwwSgYIKwYB -# BQUHMAKGPmh0dHA6Ly93d3cubWljcm9zb2Z0LmNvbS9wa2kvY2VydHMvTWljUm9v -# Q2VyQXV0XzIwMTAtMDYtMjMuY3J0MA0GCSqGSIb3DQEBCwUAA4ICAQCdVX38Kq3h -# LB9nATEkW+Geckv8qW/qXBS2Pk5HZHixBpOXPTEztTnXwnE2P9pkbHzQdTltuw8x -# 5MKP+2zRoZQYIu7pZmc6U03dmLq2HnjYNi6cqYJWAAOwBb6J6Gngugnue99qb74p -# y27YP0h1AdkY3m2CDPVtI1TkeFN1JFe53Z/zjj3G82jfZfakVqr3lbYoVSfQJL1A -# oL8ZthISEV09J+BAljis9/kpicO8F7BUhUKz/AyeixmJ5/ALaoHCgRlCGVJ1ijbC -# HcNhcy4sa3tuPywJeBTpkbKpW99Jo3QMvOyRgNI95ko+ZjtPu4b6MhrZlvSP9pEB -# 9s7GdP32THJvEKt1MMU0sHrYUP4KWN1APMdUbZ1jdEgssU5HLcEUBHG/ZPkkvnNt -# yo4JvbMBV0lUZNlz138eW0QBjloZkWsNn6Qo3GcZKCS6OEuabvshVGtqRRFHqfG3 -# rsjoiV5PndLQTHa1V1QJsWkBRH58oWFsc/4Ku+xBZj1p/cvBQUl+fpO+y/g75LcV -# v7TOPqUxUYS8vwLBgqJ7Fx0ViY1w/ue10CgaiQuPNtq6TPmb/wrpNPgkNWcr4A24 -# 5oyZ1uEi6vAnQj0llOZ0dFtq0Z4+7X6gMTN9vMvpe784cETRkPHIqzqKOghif9lw -# Y1NNje6CbaUFEMFxBmoQtB1VM1izoXBm8qGCAtQwggI9AgEBMIIBAKGB2KSB1TCB -# 0jELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1Jl -# ZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEtMCsGA1UECxMk -# TWljcm9zb2Z0IElyZWxhbmQgT3BlcmF0aW9ucyBMaW1pdGVkMSYwJAYDVQQLEx1U -# aGFsZXMgVFNTIEVTTjpBMjQwLTRCODItMTMwRTElMCMGA1UEAxMcTWljcm9zb2Z0 -# IFRpbWUtU3RhbXAgU2VydmljZaIjCgEBMAcGBSsOAwIaAxUAcGteVqFx/IbTKXHL -# euXCPRPMD7uggYMwgYCkfjB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGlu -# Z3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBv -# cmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMDAN -# BgkqhkiG9w0BAQUFAAIFAOcW7qowIhgPMjAyMjExMTAxMTI5NDZaGA8yMDIyMTEx -# MTExMjk0NlowdDA6BgorBgEEAYRZCgQBMSwwKjAKAgUA5xbuqgIBADAHAgEAAgIE -# qTAHAgEAAgIRVjAKAgUA5xhAKgIBADA2BgorBgEEAYRZCgQCMSgwJjAMBgorBgEE -# AYRZCgMCoAowCAIBAAIDB6EgoQowCAIBAAIDAYagMA0GCSqGSIb3DQEBBQUAA4GB -# AGsU2HTQg158bHX+QngoY7NVfCbGRaLjQOi8geKi26qQWAxll9QLFg4+epiG2nZB -# eQvhxeNmIzounhWfJ+gfhFMi8aBT5z4dLK9iBtmpG1Y14RmSS4andiUlS6bVNVNe -# WGObqHijMVeMOphiTaAfzR6zSASDaG0CfVm9bNBOnZZsMYIEDTCCBAkCAQEwgZMw -# fDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1Jl -# ZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEmMCQGA1UEAxMd -# TWljcm9zb2Z0IFRpbWUtU3RhbXAgUENBIDIwMTACEzMAAAG4CNTBuHngUUkAAQAA -# AbgwDQYJYIZIAWUDBAIBBQCgggFKMBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRAB -# BDAvBgkqhkiG9w0BCQQxIgQg578XwPrBwneU95xu1sHFncHeCC0UPQ7QK7PvSSby -# VpwwgfoGCyqGSIb3DQEJEAIvMYHqMIHnMIHkMIG9BCAo69Y4oHA7Q4pS+Y1NsBfr -# pIYTeWsPeGTami0X0PD7HzCBmDCBgKR+MHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQI -# EwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3Nv -# ZnQgQ29ycG9yYXRpb24xJjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBD -# QSAyMDEwAhMzAAABuAjUwbh54FFJAAEAAAG4MCIEIJVlMK4mQfdJaAZx7Unfka/I -# D4Wbw5edh/SR7TTptzRqMA0GCSqGSIb3DQEBCwUABIICAA1QlR3ywR7e+jqZ++NC -# xsIwREiwVS70CEkbH8XpPRS0mFS0SHcCfpwymGfdep3D0CWk0PIfMhXq0SD97iBI -# rOLdHglVBkMYTjGEBHyBzv/LevAZUuzoc5aqyIF4Ywa5KS4PGbMSuRK5CKAojOzH -# A/vp2/KYuADmf9kOOgOfDVicyfoqZ+3W+QaUI/k0KKV4dPLF55+y18C+Td6sR60Y -# AkcvGZObuj/OkREhdTJ1qJ2E/4RKG8gtGY1DfluLon7+UvS/ciWDWrJnHMmkxM11 -# cYuRIvLArIdq/YS2bcSnY6AVO2zYjj7gCqDN9GuCurstUKC5uxVl3VNxntC0u3Le -# BoI/R5uMYlTXodW8ukLNL6zHrQ4wI4udgW77KJref+3E1PEpZBRMxwose7Vt8lDc -# sW1vdM+eZzUXRLhDR8a0Nai7+PaNoukoGf4pvwsu8Mkeji5a0hWtU9lUVRv6nzue -# 3L2olhsbiHhAET7N6Rj0kzEhbUgfVUJrGvNlWOfN7MDr+OpArGXMPLtovbKTLtXF -# v/GrJo9wQuyqUmY6KQSRDZgOw1CcoZpJcy40HG/aOlJwk03N13OZD5H3KfHwEphR -# YnbGwGq9zUId5druSr5s40Yyl3idAkqmI5SXAm9v/gRq2X9vMU0a7KqXet9wO62F -# TqxV+7Qp48Vw6hW1g+Q7oWoc +# c29mdCBDb3Jwb3JhdGlvbjEtMCsGA1UECxMkTWljcm9zb2Z0IElyZWxhbmQgT3Bl +# cmF0aW9ucyBMaW1pdGVkMSYwJAYDVQQLEx1UaGFsZXMgVFNTIEVTTjpEMDgyLTRC +# RkQtRUVCQTElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUtU3RhbXAgU2VydmljZTCC +# AiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAIhOFYMzkjWAE9UVnXF9hRGv +# 0xBRxc+I5Hu3hxVFXyK3u38xusEb0pLkwjgGtDsaLLbrlMxqX3tFb/3BgEPEC3L0 +# wX76gD8zHt+wiBV5mq5BWop29qRrgMJKKCPcpQnSjs9B/4XMFFvrpdPicZDv43FL +# gz9fHqMq0LJDw5JAHGDS30TCY9OF43P4d44Z9lE7CaVS2pJMF3L453MXB5yYK/KD +# bilhERP1jxn2yl+tGCRguIAsMG0oeOhXaw8uSGOhS6ACSHb+ebi0038MFHyoTNhK +# f+SYo4OpSY3xP4+swBBTKDoYP1wH+CfxG6h9fymBJQPQZaqfl0riiDLjmDunQtH1 +# GD64Air5k9Jdwhq5wLmSWXjyFVL+IDfOpdixJ6f5o+MhE6H4t31w+prygHmd2UHQ +# 657UGx6FNuzwC+SpAHmV76MZYac4uAhTgaP47P2eeS1ockvyhl9ya+9JzPfMkug3 +# xevzFADWiLRMr066EMV7q3JSRAsnCS9GQ08C4FKPbSh8OPM33Lng0ffxANnHAAX/ +# DE7cHcx7l9jaV3Acmkj7oqir4Eh2u5YxwiaTE37XaMumX2ES3PJ5NBaXq7YdLJwy +# SD+U9pk/tl4dQ1t/Eeo7uDTliOyQkD8I74xpVB0T31/67KHfkBkFVvy6wye21V+9 +# IC8uSD++RgD3RwtN2kE/AgMBAAGjggFJMIIBRTAdBgNVHQ4EFgQUimLm8QMeJa25 +# j9MWeabI2HSvZOUwHwYDVR0jBBgwFoAUn6cVXQBeYl2D9OXSZacbUzUZ6XIwXwYD +# VR0fBFgwVjBUoFKgUIZOaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9j +# cmwvTWljcm9zb2Z0JTIwVGltZS1TdGFtcCUyMFBDQSUyMDIwMTAoMSkuY3JsMGwG +# CCsGAQUFBwEBBGAwXjBcBggrBgEFBQcwAoZQaHR0cDovL3d3dy5taWNyb3NvZnQu +# Y29tL3BraW9wcy9jZXJ0cy9NaWNyb3NvZnQlMjBUaW1lLVN0YW1wJTIwUENBJTIw +# MjAxMCgxKS5jcnQwDAYDVR0TAQH/BAIwADAWBgNVHSUBAf8EDDAKBggrBgEFBQcD +# CDAOBgNVHQ8BAf8EBAMCB4AwDQYJKoZIhvcNAQELBQADggIBAF/I8U6hbZhvDcn9 +# 6nZ6tkbSEjXPvKZ6wroaXcgstEhpgaeEwleLuPXHLzEWtuJuYz4eshmhXqFr49lb +# AcX5SN5/cEsP0xdFayb7U5P94JZd3HjFvpWRNoNBhF3SDM0A38sI2H+hjhB/VfX1 +# XcZiei1ROPAyCHcBgHLyQrEu6mnb3HhbIdr8h0Ta7WFylGhLSFW6wmzKusP6aOlm +# nGSac5NMfla6lRvTYHd28rbbCgfSm1RhTgoZj+W8DTKtiEMwubHJ3mIPKmo8xtJI +# WXPnXq6XKgldrL5cynLMX/0WX65OuWbHV5GTELdfWvGV3DaZrHPUQ/UP31Keqb2x +# jVCb30LVwgbjIvYS77N1dARkN8F/9pJ1gO4IvZWMwyMlKKFGojO1f1wbjSWcA/57 +# tsc+t2blrMWgSNHgzDr01jbPSupRjy3Ht9ZZs4xN02eiX3eG297NrtC6l4c/gzn2 +# 0eqoqWx/uHWxmTgB0F5osBuTHOe77DyEA0uhArGlgKP91jghgt/OVHoH65g0QqCt +# gZ+36mnCEg6IOhFoFrCc0fJFGVmb1+17gEe+HRMM7jBk4O06J+IooFrI3e3PJjPr +# Qano/MyE3h+zAuBWGMDRcUlNKCDU7dGnWvH3XWwLrCCIcz+3GwRUMsLsDdPW2OVv +# 7v1eEJiMSIZ2P+M7L20Q8aznU4OAMIIHcTCCBVmgAwIBAgITMwAAABXF52ueAptJ +# mQAAAAAAFTANBgkqhkiG9w0BAQsFADCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgT +# Cldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29m +# dCBDb3Jwb3JhdGlvbjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNh +# dGUgQXV0aG9yaXR5IDIwMTAwHhcNMjEwOTMwMTgyMjI1WhcNMzAwOTMwMTgzMjI1 +# WjB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMH +# UmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSYwJAYDVQQD +# Ex1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMDCCAiIwDQYJKoZIhvcNAQEB +# BQADggIPADCCAgoCggIBAOThpkzntHIhC3miy9ckeb0O1YLT/e6cBwfSqWxOdcjK +# NVf2AX9sSuDivbk+F2Az/1xPx2b3lVNxWuJ+Slr+uDZnhUYjDLWNE893MsAQGOhg +# fWpSg0S3po5GawcU88V29YZQ3MFEyHFcUTE3oAo4bo3t1w/YJlN8OWECesSq/XJp +# rx2rrPY2vjUmZNqYO7oaezOtgFt+jBAcnVL+tuhiJdxqD89d9P6OU8/W7IVWTe/d +# vI2k45GPsjksUZzpcGkNyjYtcI4xyDUoveO0hyTD4MmPfrVUj9z6BVWYbWg7mka9 +# 7aSueik3rMvrg0XnRm7KMtXAhjBcTyziYrLNueKNiOSWrAFKu75xqRdbZ2De+JKR +# Hh09/SDPc31BmkZ1zcRfNN0Sidb9pSB9fvzZnkXftnIv231fgLrbqn427DZM9itu +# qBJR6L8FA6PRc6ZNN3SUHDSCD/AQ8rdHGO2n6Jl8P0zbr17C89XYcz1DTsEzOUyO +# ArxCaC4Q6oRRRuLRvWoYWmEBc8pnol7XKHYC4jMYctenIPDC+hIK12NvDMk2ZItb +# oKaDIV1fMHSRlJTYuVD5C4lh8zYGNRiER9vcG9H9stQcxWv2XFJRXRLbJbqvUAV6 +# bMURHXLvjflSxIUXk8A8FdsaN8cIFRg/eKtFtvUeh17aj54WcmnGrnu3tz5q4i6t +# AgMBAAGjggHdMIIB2TASBgkrBgEEAYI3FQEEBQIDAQABMCMGCSsGAQQBgjcVAgQW +# BBQqp1L+ZMSavoKRPEY1Kc8Q/y8E7jAdBgNVHQ4EFgQUn6cVXQBeYl2D9OXSZacb +# UzUZ6XIwXAYDVR0gBFUwUzBRBgwrBgEEAYI3TIN9AQEwQTA/BggrBgEFBQcCARYz +# aHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9Eb2NzL1JlcG9zaXRvcnku +# aHRtMBMGA1UdJQQMMAoGCCsGAQUFBwMIMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIA +# QwBBMAsGA1UdDwQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFNX2 +# VsuP6KJcYmjRPZSQW9fOmhjEMFYGA1UdHwRPME0wS6BJoEeGRWh0dHA6Ly9jcmwu +# bWljcm9zb2Z0LmNvbS9wa2kvY3JsL3Byb2R1Y3RzL01pY1Jvb0NlckF1dF8yMDEw +# LTA2LTIzLmNybDBaBggrBgEFBQcBAQROMEwwSgYIKwYBBQUHMAKGPmh0dHA6Ly93 +# d3cubWljcm9zb2Z0LmNvbS9wa2kvY2VydHMvTWljUm9vQ2VyQXV0XzIwMTAtMDYt +# MjMuY3J0MA0GCSqGSIb3DQEBCwUAA4ICAQCdVX38Kq3hLB9nATEkW+Geckv8qW/q +# XBS2Pk5HZHixBpOXPTEztTnXwnE2P9pkbHzQdTltuw8x5MKP+2zRoZQYIu7pZmc6 +# U03dmLq2HnjYNi6cqYJWAAOwBb6J6Gngugnue99qb74py27YP0h1AdkY3m2CDPVt +# I1TkeFN1JFe53Z/zjj3G82jfZfakVqr3lbYoVSfQJL1AoL8ZthISEV09J+BAljis +# 9/kpicO8F7BUhUKz/AyeixmJ5/ALaoHCgRlCGVJ1ijbCHcNhcy4sa3tuPywJeBTp +# kbKpW99Jo3QMvOyRgNI95ko+ZjtPu4b6MhrZlvSP9pEB9s7GdP32THJvEKt1MMU0 +# sHrYUP4KWN1APMdUbZ1jdEgssU5HLcEUBHG/ZPkkvnNtyo4JvbMBV0lUZNlz138e +# W0QBjloZkWsNn6Qo3GcZKCS6OEuabvshVGtqRRFHqfG3rsjoiV5PndLQTHa1V1QJ +# sWkBRH58oWFsc/4Ku+xBZj1p/cvBQUl+fpO+y/g75LcVv7TOPqUxUYS8vwLBgqJ7 +# Fx0ViY1w/ue10CgaiQuPNtq6TPmb/wrpNPgkNWcr4A245oyZ1uEi6vAnQj0llOZ0 +# dFtq0Z4+7X6gMTN9vMvpe784cETRkPHIqzqKOghif9lwY1NNje6CbaUFEMFxBmoQ +# tB1VM1izoXBm8qGCAtQwggI9AgEBMIIBAKGB2KSB1TCB0jELMAkGA1UEBhMCVVMx +# EzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoT +# FU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEtMCsGA1UECxMkTWljcm9zb2Z0IElyZWxh +# bmQgT3BlcmF0aW9ucyBMaW1pdGVkMSYwJAYDVQQLEx1UaGFsZXMgVFNTIEVTTjpE +# MDgyLTRCRkQtRUVCQTElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUtU3RhbXAgU2Vy +# dmljZaIjCgEBMAcGBSsOAwIaAxUAdqNHe113gCJ87aZIGa5QBUqIwvKggYMwgYCk +# fjB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMH +# UmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSYwJAYDVQQD +# Ex1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAxMDANBgkqhkiG9w0BAQUFAAIF +# AOiyf1swIhgPMjAyMzA5MTgxNTQ4NDNaGA8yMDIzMDkxOTE1NDg0M1owdDA6Bgor +# BgEEAYRZCgQBMSwwKjAKAgUA6LJ/WwIBADAHAgEAAgIJSjAHAgEAAgISJDAKAgUA +# 6LPQ2wIBADA2BgorBgEEAYRZCgQCMSgwJjAMBgorBgEEAYRZCgMCoAowCAIBAAID +# B6EgoQowCAIBAAIDAYagMA0GCSqGSIb3DQEBBQUAA4GBAGK+6UVMbVgt4qWdPk/1 +# tYxGjavQWgZ3LPfp9l3mh/tQK2RhpjsBgKJO+VVBXcUW3YQb5qP9g40+jrcIFlfy +# vrAK3UpbfuIZ6DJ6AayEF30fseVPvwaqjl/BJlKUL3ofsjEMcZPdpfHQv4Zdj3rr +# cWGEIG68RqDIePRRKRZEJtI0MYIEDTCCBAkCAQEwgZMwfDELMAkGA1UEBhMCVVMx +# EzARBgNVBAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoT +# FU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUt +# U3RhbXAgUENBIDIwMTACEzMAAAG6Hz8Z98F1vXwAAQAAAbowDQYJYIZIAWUDBAIB +# BQCgggFKMBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAvBgkqhkiG9w0BCQQx +# IgQgYadrVhYugkNn/ywjh6tJ37ntH5tUO1WvoJ2sa5Mz6LIwgfoGCyqGSIb3DQEJ +# EAIvMYHqMIHnMIHkMIG9BCApVb08M25w+tYGWsmlGtp1gy1nPcqWfqgMF3nlWYVz +# BTCBmDCBgKR+MHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAw +# DgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24x +# JjAkBgNVBAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEwAhMzAAABuh8/ +# GffBdb18AAEAAAG6MCIEIMHkOGC427PqmUI7Oe7xVuezks+e+hMM+17Nfgn9Gbmw +# MA0GCSqGSIb3DQEBCwUABIICAEKE7ZkmQ1xDsee8ZSZP8Kkt2YJLG3nLR32JBRu3 +# uX7TPTDw9phd40N2ryva3Xjzht/JOPa0F4mg++YIwylXVIR6EqKNVLsIA/X8AGFa +# ti+AJp6qNe9grV8DBK00whojtMK8JZhufOb7LEon5rBFEnJx3g8JhCvAqXFzxw+M +# ctqJFm6+1ynuI7mKayA89TOLBmI4RviICjMZlsW3kNXRS1GryKt7H+C8y9kiLEMX +# efauGyoMO8sToIxgrq2HZF88/b+y8c3cX+Q5iazWLzMYeWUUPrqWcIbjGjIFBMl9 +# weOXEAZVo6TSGDZOQkYi/FZxKWllnxVRN1S2Al5IUUvgXGl9ZpsW2DyM1S8Qxe+a +# VrxwkOWKzHlnFo1qGz0Iq9ImHVqr2dOC5bDVMu+jlOA1LiZC5aHxuxaHWBN73Wp7 +# Hjy8h73drsmmiXovOWly7lWLatIuPJh00iiyBXdDtjmeDjso3aadUII5FQ1QWZ4F +# 4VWo161Gx+TxGlUt//4Hns5bn4UEGE43g9OCQuQ/WFMqdb3dHCzkkHDhWHbdpBy7 +# oHHEsAdgjMdQHWfnxhCj0ZHEOupc9j1CXpQtN/B6uzsQQ/Mp34Rhsgn+/REVAwpS +# O7G69KWZrePZJiNrV/+eRn8ya6s8WNQAGB5zIQc8o+K9RGctLBOWcsRya9sqvL6r +# xUQ2 # SIG # End signature block diff --git a/tools/dotnet-install.sh b/tools/dotnet-install.sh index 5327f34e0..4547589b5 100755 --- a/tools/dotnet-install.sh +++ b/tools/dotnet-install.sh @@ -310,6 +310,14 @@ get_machine_architecture() { echo "s390x" return 0 ;; + ppc64le) + echo "ppc64le" + return 0 + ;; + loongarch64) + echo "loongarch64" + return 0 + ;; esac fi @@ -347,6 +355,14 @@ get_normalized_architecture_from_architecture() { echo "s390x" return 0 ;; + ppc64le) + echo "ppc64le" + return 0 + ;; + loongarch64) + echo "loongarch64" + return 0 + ;; esac say_err "Architecture \`$architecture\` not supported. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues" @@ -367,8 +383,8 @@ get_normalized_architecture_for_specific_sdk_version() { if [ "$osname" == "osx" ] && [ "$architecture" == "arm64" ] && { [ "$is_version_support_arm64" = false ] || [ "$is_channel_support_arm64" = false ]; }; then #check if rosetta is installed - if [ "$(/usr/bin/pgrep oahd >/dev/null 2>&1;echo $?)" -eq 0 ]; then - say_verbose "Changing user architecture from '$architecture' to 'x64' because .NET SDKs prior to version 6.0 do not support arm64." + if [ "$(/usr/bin/pgrep oahd >/dev/null 2>&1;echo $?)" -eq 0 ]; then + say_verbose "Changing user architecture from '$architecture' to 'x64' because .NET SDKs prior to version 6.0 do not support arm64." echo "x64" return 0; else @@ -386,7 +402,7 @@ get_normalized_architecture_for_specific_sdk_version() { is_arm64_supported() { #any channel or version that starts with the specified versions case "$1" in - ( "1"* | "2"* | "3"* | "4"* | "5"*) + ( "1"* | "2"* | "3"* | "4"* | "5"*) echo false return 0 esac @@ -538,6 +554,40 @@ is_dotnet_package_installed() { fi } +# args: +# downloaded file - $1 +# remote_file_size - $2 +validate_remote_local_file_sizes() +{ + eval $invocation + + local downloaded_file="$1" + local remote_file_size="$2" + local file_size='' + + if [[ "$OSTYPE" == "linux-gnu"* ]]; then + file_size="$(stat -c '%s' "$downloaded_file")" + elif [[ "$OSTYPE" == "darwin"* ]]; then + # hardcode in order to avoid conflicts with GNU stat + file_size="$(/usr/bin/stat -f '%z' "$downloaded_file")" + fi + + if [ -n "$file_size" ]; then + say "Downloaded file size is $file_size bytes." + + if [ -n "$remote_file_size" ] && [ -n "$file_size" ]; then + if [ "$remote_file_size" -ne "$file_size" ]; then + say "The remote and local file sizes are not equal. The remote file size is $remote_file_size bytes and the local size is $file_size bytes. The local package may be corrupted." + else + say "The remote and local file sizes are equal." + fi + fi + + else + say "Either downloaded or local package size can not be measured. One of them may be corrupted." + fi +} + # args: # azure_feed - $1 # channel - $2 @@ -715,7 +765,7 @@ get_specific_product_version() { fi fi done - + # Getting the version number with productVersion.txt has failed. Try parsing the download link for a version number. say_verbose "Failed to get the version using productVersion.txt file. Download link will be parsed instead." specific_product_version="$(get_product_specific_version_from_download_link "$package_download_link" "$specific_version")" @@ -780,7 +830,7 @@ get_product_specific_version_from_download_link() local download_link="$1" local specific_version="$2" - local specific_product_version="" + local specific_product_version="" if [ -z "$download_link" ]; then echo "$specific_version" @@ -906,14 +956,39 @@ copy_files_or_dirs_from_list() { done } +# args: +# zip_uri - $1 +get_remote_file_size() { + local zip_uri="$1" + + if machine_has "curl"; then + file_size=$(curl -sI "$zip_uri" | grep -i content-length | awk '{ num = $2 + 0; print num }') + elif machine_has "wget"; then + file_size=$(wget --spider --server-response -O /dev/null "$zip_uri" 2>&1 | grep -i 'Content-Length:' | awk '{ num = $2 + 0; print num }') + else + say "Neither curl nor wget is available on this system." + return + fi + + if [ -n "$file_size" ]; then + say "Remote file $zip_uri size is $file_size bytes." + echo "$file_size" + else + say_verbose "Content-Length header was not extracted for $zip_uri." + echo "" + fi +} + # args: # zip_path - $1 # out_path - $2 +# remote_file_size - $3 extract_dotnet_package() { eval $invocation local zip_path="$1" local out_path="$2" + local remote_file_size="$3" local temp_out_path="$(mktemp -d "$temporary_file_template")" @@ -923,9 +998,13 @@ extract_dotnet_package() { local folders_with_version_regex='^.*/[0-9]+\.[0-9]+[^/]+/' find "$temp_out_path" -type f | grep -Eo "$folders_with_version_regex" | sort | copy_files_or_dirs_from_list "$temp_out_path" "$out_path" false find "$temp_out_path" -type f | grep -Ev "$folders_with_version_regex" | copy_files_or_dirs_from_list "$temp_out_path" "$out_path" "$override_non_versioned_files" - + + validate_remote_local_file_sizes "$zip_path" "$remote_file_size" + rm -rf "$temp_out_path" - rm -f "$zip_path" && say_verbose "Temporary zip file $zip_path was removed" + if [ -z ${keep_zip+x} ]; then + rm -f "$zip_path" && say_verbose "Temporary zip file $zip_path was removed" + fi if [ "$failed" = true ]; then say_err "Extraction failed" @@ -1068,7 +1147,7 @@ downloadcurl() { curl $curl_options -o "$out_path" "$remote_path_with_credential" 2>&1 curl_exit_code=$? fi - + if [ $curl_exit_code -gt 0 ]; then download_error_msg="Unable to download $remote_path." # Check for curl timeout codes @@ -1146,7 +1225,7 @@ get_download_link_from_aka_ms() { say_warning "Specifying quality for STS or LTS channel is not supported, the quality will be ignored." fi - say_verbose "Retrieving primary payload URL from aka.ms for channel: '$normalized_channel', quality: '$normalized_quality', product: '$normalized_product', os: '$normalized_os', architecture: '$normalized_architecture'." + say_verbose "Retrieving primary payload URL from aka.ms for channel: '$normalized_channel', quality: '$normalized_quality', product: '$normalized_product', os: '$normalized_os', architecture: '$normalized_architecture'." #construct aka.ms link aka_ms_link="https://aka.ms/dotnet" @@ -1334,7 +1413,7 @@ generate_regular_links() { if [ "$valid_legacy_download_link" = true ]; then say_verbose "Constructed legacy named payload URL: $legacy_download_link" - + download_links+=($legacy_download_link) specific_versions+=($specific_version) effective_versions+=($effective_version) @@ -1362,7 +1441,7 @@ print_dry_run() { resolved_version=${specific_versions[0]} repeatable_command="./$script_name --version "\""$resolved_version"\"" --install-dir "\""$install_root"\"" --architecture "\""$normalized_architecture"\"" --os "\""$normalized_os"\""" - + if [ ! -z "$normalized_quality" ]; then repeatable_command+=" --quality "\""$normalized_quality"\""" fi @@ -1419,9 +1498,10 @@ install_dotnet() { eval $invocation local download_failed=false local download_completed=false + local remote_file_size=0 mkdir -p "$install_root" - zip_path="$(mktemp "$temporary_file_template")" + zip_path="${zip_path:-$(mktemp "$temporary_file_template")}" say_verbose "Zip path: $zip_path" for link_index in "${!download_links[@]}" @@ -1459,8 +1539,10 @@ install_dotnet() { return 1 fi + remote_file_size="$(get_remote_file_size "$download_link")" + say "Extracting zip from $download_link" - extract_dotnet_package "$zip_path" "$install_root" || return 1 + extract_dotnet_package "$zip_path" "$install_root" "$remote_file_size" || return 1 # Check if the SDK version is installed; if not, fail the installation. # if the version contains "RTM" or "servicing"; check if a 'release-type' SDK version is installed. @@ -1610,6 +1692,14 @@ do override_non_versioned_files=false non_dynamic_parameters+=" $name" ;; + --keep-zip|-[Kk]eep[Zz]ip) + keep_zip=true + non_dynamic_parameters+=" $name" + ;; + --zip-path|-[Zz]ip[Pp]ath) + shift + zip_path="$1" + ;; -?|--?|-h|--help|-[Hh]elp) script_name="$(basename "$0")" echo ".NET Tools Installer" @@ -1617,6 +1707,10 @@ do echo " $script_name -h|-?|--help" echo "" echo "$script_name is a simple command line interface for obtaining dotnet cli." + echo " Note that the intended use of this script is for Continuous Integration (CI) scenarios, where:" + echo " - The SDK needs to be installed without user interaction and without admin rights." + echo " - The SDK installation doesn't need to persist across multiple CI runs." + echo " To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer." echo "" echo "Options:" echo " -c,--channel Download from the channel specified, Defaults to \`$channel\`." @@ -1640,9 +1734,9 @@ do echo " -q,--quality Download the latest build of specified quality in the channel." echo " -Quality" echo " The possible values are: daily, signed, validated, preview, GA." - echo " Works only in combination with channel. Not applicable for STS and LTS channels and will be ignored if those channels are used." - echo " For SDK use channel in A.B.Cxx format. Using quality for SDK together with channel in A.B format is not supported." - echo " Supported since 5.0 release." + echo " Works only in combination with channel. Not applicable for STS and LTS channels and will be ignored if those channels are used." + echo " For SDK use channel in A.B.Cxx format. Using quality for SDK together with channel in A.B format is not supported." + echo " Supported since 5.0 release." echo " Note: The version parameter overrides the channel parameter when any version other than 'latest' is used, and therefore overrides the quality." echo " --internal,-Internal Download internal builds. Requires providing credentials via --feed-credential parameter." echo " --feed-credential Token to access Azure feed. Used as a query string to append to the Azure feed." @@ -1651,7 +1745,7 @@ do echo " -InstallDir" echo " --architecture Architecture of dotnet binaries to be installed, Defaults to \`$architecture\`." echo " --arch,-Architecture,-Arch" - echo " Possible values: x64, arm, arm64 and s390x" + echo " Possible values: x64, arm, arm64, s390x, ppc64le and loongarch64" echo " --os Specifies operating system to be used when selecting the installer." echo " Overrides the OS determination approach used by the script. Supported values: osx, linux, linux-musl, freebsd, rhel.6." echo " In case any other value is provided, the platform will be determined by the script based on machine configuration." @@ -1676,6 +1770,8 @@ do echo " --no-cdn,-NoCdn Disable downloading from the Azure CDN, and use the uncached feed directly." echo " --jsonfile Determines the SDK version from a user specified global.json file." echo " Note: global.json must have a value for 'SDK:Version'" + echo " --keep-zip,-KeepZip If set, downloaded file is kept." + echo " --zip-path, -ZipPath If set, downloaded file is stored at the specified path." echo " -?,--?,-h,--help,-Help Shows this help message" echo "" echo "Install Location:" @@ -1694,10 +1790,10 @@ do shift done -say "Note that the intended use of this script is for Continuous Integration (CI) scenarios, where:" -say "- The SDK needs to be installed without user interaction and without admin rights." -say "- The SDK installation doesn't need to persist across multiple CI runs." -say "To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer.\n" +say_verbose "Note that the intended use of this script is for Continuous Integration (CI) scenarios, where:" +say_verbose "- The SDK needs to be installed without user interaction and without admin rights." +say_verbose "- The SDK installation doesn't need to persist across multiple CI runs." +say_verbose "To set up a development environment or to run apps, use installers rather than this script. Visit https://dotnet.microsoft.com/download to get the installer.\n" if [ "$internal" = true ] && [ -z "$(echo $feed_credential)" ]; then message="Provide credentials via --feed-credential parameter." From f884919df12b63ebf41de55756dc8ab090a7a00e Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 29 Oct 2023 22:30:37 +0100 Subject: [PATCH 120/157] Update shipped API per v4.0 --- .../PublicAPI/net6.0/PublicAPI.Shipped.txt | 44 +++++++++++-------- .../PublicAPI/net6.0/PublicAPI.Unshipped.txt | 44 ------------------- .../netstandard2.0/PublicAPI.Shipped.txt | 24 ++++++---- .../netstandard2.0/PublicAPI.Unshipped.txt | 24 ---------- .../netstandard2.1/PublicAPI.Shipped.txt | 32 +++++++++----- .../netstandard2.1/PublicAPI.Unshipped.txt | 32 -------------- 6 files changed, 62 insertions(+), 138 deletions(-) diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt index 91fd806e7..b393e18b7 100644 --- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt @@ -58,6 +58,8 @@ MoreLinq.Extensions.LeadExtension MoreLinq.Extensions.LeftJoinExtension MoreLinq.Extensions.MaxByExtension MoreLinq.Extensions.MinByExtension +MoreLinq.Extensions.MaximaExtension +MoreLinq.Extensions.MinimaExtension MoreLinq.Extensions.MoveExtension MoreLinq.Extensions.OrderByExtension MoreLinq.Extensions.OrderedMergeExtension @@ -164,8 +166,8 @@ static MoreLinq.Extensions.AssertExtension.Assert(this System.Collectio static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -258,6 +260,10 @@ static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Colle static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! @@ -410,7 +416,7 @@ static MoreLinq.MoreEnumerable.Aggregate static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource -static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -418,8 +424,8 @@ static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Gene static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -429,14 +435,13 @@ static MoreLinq.MoreEnumerable.Cartesian(this System.Collec static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int -static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -515,10 +520,14 @@ static MoreLinq.MoreEnumerable.LeftJoin(this Sys static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! @@ -556,7 +565,7 @@ static MoreLinq.MoreEnumerable.Partition(this System.Co static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult static MoreLinq.MoreEnumerable.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! @@ -596,7 +605,7 @@ static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnume static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! @@ -619,7 +628,7 @@ static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnume static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! @@ -652,8 +661,8 @@ static MoreLinq.MoreEnumerable.ToDictionary(this System.Collection static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! @@ -666,7 +675,6 @@ static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Unfold(TState state, System.Func! generator, System.Func! predicate, System.Func! stateSelector, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt index 8b26bf00b..7dc5c5811 100644 --- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt @@ -1,45 +1 @@ #nullable enable -*REMOVED*static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -*REMOVED*static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -*REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! -*REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -*REMOVED*static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -MoreLinq.Extensions.MaximaExtension -MoreLinq.Extensions.MinimaExtension -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt index 1f9122f06..980074ac0 100644 --- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt @@ -56,6 +56,8 @@ MoreLinq.Extensions.LeadExtension MoreLinq.Extensions.LeftJoinExtension MoreLinq.Extensions.MaxByExtension MoreLinq.Extensions.MinByExtension +MoreLinq.Extensions.MaximaExtension +MoreLinq.Extensions.MinimaExtension MoreLinq.Extensions.MoveExtension MoreLinq.Extensions.OrderByExtension MoreLinq.Extensions.OrderedMergeExtension @@ -158,8 +160,8 @@ static MoreLinq.Extensions.AssertExtension.Assert(this System.Collectio static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -252,6 +254,10 @@ static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Colle static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! @@ -404,7 +410,7 @@ static MoreLinq.MoreEnumerable.Aggregate static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource -static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -412,8 +418,8 @@ static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Gene static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -423,7 +429,6 @@ static MoreLinq.MoreEnumerable.Cartesian(this System.Collec static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int -static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! @@ -513,6 +518,10 @@ static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Gene static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! @@ -550,7 +559,7 @@ static MoreLinq.MoreEnumerable.Partition(this System.Co static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult static MoreLinq.MoreEnumerable.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! @@ -660,7 +669,6 @@ static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Unfold(TState state, System.Func! generator, System.Func! predicate, System.Func! stateSelector, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt index baeef302c..7dc5c5811 100644 --- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt @@ -1,25 +1 @@ #nullable enable -*REMOVED*static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -*REMOVED*static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -*REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -MoreLinq.Extensions.MaximaExtension -MoreLinq.Extensions.MinimaExtension -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt index 91fd806e7..c0f90f6d2 100644 --- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt @@ -58,6 +58,8 @@ MoreLinq.Extensions.LeadExtension MoreLinq.Extensions.LeftJoinExtension MoreLinq.Extensions.MaxByExtension MoreLinq.Extensions.MinByExtension +MoreLinq.Extensions.MaximaExtension +MoreLinq.Extensions.MinimaExtension MoreLinq.Extensions.MoveExtension MoreLinq.Extensions.OrderByExtension MoreLinq.Extensions.OrderedMergeExtension @@ -164,8 +166,8 @@ static MoreLinq.Extensions.AssertExtension.Assert(this System.Collectio static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -258,6 +260,10 @@ static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Colle static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! @@ -410,7 +416,7 @@ static MoreLinq.MoreEnumerable.Aggregate static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource -static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -418,8 +424,8 @@ static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Gene static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -429,7 +435,6 @@ static MoreLinq.MoreEnumerable.Cartesian(this System.Collec static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int -static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! @@ -519,6 +524,10 @@ static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Gene static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! @@ -556,7 +565,7 @@ static MoreLinq.MoreEnumerable.Partition(this System.Co static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult static MoreLinq.MoreEnumerable.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! @@ -596,7 +605,7 @@ static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnume static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! @@ -619,7 +628,7 @@ static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnume static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! @@ -652,8 +661,8 @@ static MoreLinq.MoreEnumerable.ToDictionary(this System.Collection static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! @@ -666,7 +675,6 @@ static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Unfold(TState state, System.Func! generator, System.Func! predicate, System.Func! stateSelector, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt index 0a76e35e0..7dc5c5811 100644 --- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt @@ -1,33 +1 @@ #nullable enable -*REMOVED*static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -*REMOVED*static MoreLinq.MoreEnumerable.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -*REMOVED*static MoreLinq.MoreEnumerable.Concat(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -*REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! -*REMOVED*static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -*REMOVED*static MoreLinq.MoreEnumerable.Windowed(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -MoreLinq.Extensions.MaximaExtension -MoreLinq.Extensions.MinimaExtension -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! From 318361afe1dae79a043ef974bbf538421a4c03ae Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 13 Nov 2023 19:35:22 +0100 Subject: [PATCH 121/157] Prepare for 4.1 --- MoreLinq/MoreLinq.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 4ed9e868b..fea6ba41c 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -118,7 +118,7 @@ $([System.Text.RegularExpressions.Regex]::Replace($(Copyright), `\s+`, ` `).Trim()) MoreLINQ en-US - 4.0.0 + 4.1.0 MoreLINQ Developers. netstandard2.0;netstandard2.1;net6.0 portable From b9dd2a6a281808c8f35bd804ddc60d74a2d59f84 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 13 Nov 2023 19:46:48 +0100 Subject: [PATCH 122/157] Update test packages to latest versions --- MoreLinq.Test/MoreLinq.Test.csproj | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index 77e2b5cbc..c30b247bb 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -26,12 +26,12 @@ runtime; build; native; contentfiles; analyzers all - - + + all runtime; build; native; contentfiles; analyzers; buildtransitive - + all runtime; build; native; contentfiles; analyzers; buildtransitive @@ -39,7 +39,7 @@ - + From 97dbe9874072cdf149c21daa663c22a9de9779c6 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Wed, 15 Nov 2023 23:11:35 +0100 Subject: [PATCH 123/157] Set package validation baseline to version 4.0 --- MoreLinq/CompatibilitySuppressions.xml | 208 +++---------------------- MoreLinq/MoreLinq.csproj | 2 +- 2 files changed, 21 insertions(+), 189 deletions(-) diff --git a/MoreLinq/CompatibilitySuppressions.xml b/MoreLinq/CompatibilitySuppressions.xml index ead8c1613..ffe9243dc 100644 --- a/MoreLinq/CompatibilitySuppressions.xml +++ b/MoreLinq/CompatibilitySuppressions.xml @@ -1,232 +1,64 @@ - - CP0001 - T:MoreLinq.Extensions.AppendExtension - lib/net462/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true - - - CP0001 - T:MoreLinq.Extensions.PrependExtension - lib/net462/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true - - - CP0001 - T:MoreLinq.Extensions.AppendExtension - lib/net6.0/MoreLinq.dll - lib/net6.0/MoreLinq.dll - true - - - CP0001 - T:MoreLinq.Extensions.PrependExtension - lib/net6.0/MoreLinq.dll - lib/net6.0/MoreLinq.dll - true - - - CP0001 - T:MoreLinq.Extensions.AppendExtension - lib/netstandard2.0/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true - - - CP0001 - T:MoreLinq.Extensions.PrependExtension - lib/netstandard2.0/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true - - - CP0001 - T:MoreLinq.Extensions.AppendExtension - lib/netstandard2.1/MoreLinq.dll - lib/netstandard2.1/MoreLinq.dll - true - - - CP0001 - T:MoreLinq.Extensions.PrependExtension - lib/netstandard2.1/MoreLinq.dll - lib/netstandard2.1/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.Extensions.BatchExtension.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) - lib/net462/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) - lib/net462/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) - lib/net462/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) - lib/net462/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0) - lib/net462/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.Windowed``1(System.Collections.Generic.IEnumerable{``0},System.Int32) - lib/net462/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.Extensions.BatchExtension.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) - lib/net6.0/MoreLinq.dll - lib/net6.0/MoreLinq.dll - true - CP0002 - M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) - lib/net6.0/MoreLinq.dll - lib/net6.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) - lib/net6.0/MoreLinq.dll - lib/net6.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) - lib/net6.0/MoreLinq.dll - lib/net6.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0) - lib/net6.0/MoreLinq.dll - lib/net6.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.Windowed``1(System.Collections.Generic.IEnumerable{``0},System.Int32) - lib/net6.0/MoreLinq.dll - lib/net6.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.Extensions.BatchExtension.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) - lib/netstandard2.0/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) - lib/netstandard2.0/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true - - - CP0002 - M:MoreLinq.MoreEnumerable.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) + M:MoreLinq.MoreEnumerable.SkipLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32) lib/netstandard2.0/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true + lib/netstandard2.1/MoreLinq.dll CP0002 - M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) + M:MoreLinq.MoreEnumerable.TakeLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32) lib/netstandard2.0/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true + lib/netstandard2.1/MoreLinq.dll CP0002 - M:MoreLinq.MoreEnumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0) + M:MoreLinq.MoreEnumerable.ToHashSet``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEqualityComparer{``0}) lib/netstandard2.0/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true + lib/netstandard2.1/MoreLinq.dll CP0002 - M:MoreLinq.MoreEnumerable.Windowed``1(System.Collections.Generic.IEnumerable{``0},System.Int32) + M:MoreLinq.MoreEnumerable.ToHashSet``1(System.Collections.Generic.IEnumerable{``0}) lib/netstandard2.0/MoreLinq.dll - lib/netstandard2.0/MoreLinq.dll - true + lib/netstandard2.1/MoreLinq.dll CP0002 - M:MoreLinq.Extensions.BatchExtension.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) + M:MoreLinq.MoreEnumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) lib/netstandard2.1/MoreLinq.dll - lib/netstandard2.1/MoreLinq.dll - true + lib/net6.0/MoreLinq.dll CP0002 - M:MoreLinq.MoreEnumerable.Append``1(System.Collections.Generic.IEnumerable{``0},``0) + M:MoreLinq.MoreEnumerable.DistinctBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) lib/netstandard2.1/MoreLinq.dll - lib/netstandard2.1/MoreLinq.dll - true + lib/net6.0/MoreLinq.dll CP0002 - M:MoreLinq.MoreEnumerable.Batch``2(System.Collections.Generic.IEnumerable{``0},System.Int32,System.Func{System.Collections.Generic.IEnumerable{``0},``1}) + M:MoreLinq.MoreEnumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) lib/netstandard2.1/MoreLinq.dll - lib/netstandard2.1/MoreLinq.dll - true + lib/net6.0/MoreLinq.dll CP0002 - M:MoreLinq.MoreEnumerable.Concat``1(System.Collections.Generic.IEnumerable{``0},``0) + M:MoreLinq.MoreEnumerable.MaxBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) lib/netstandard2.1/MoreLinq.dll - lib/netstandard2.1/MoreLinq.dll - true + lib/net6.0/MoreLinq.dll CP0002 - M:MoreLinq.MoreEnumerable.Prepend``1(System.Collections.Generic.IEnumerable{``0},``0) + M:MoreLinq.MoreEnumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IComparer{``1}) lib/netstandard2.1/MoreLinq.dll - lib/netstandard2.1/MoreLinq.dll - true + lib/net6.0/MoreLinq.dll CP0002 - M:MoreLinq.MoreEnumerable.Windowed``1(System.Collections.Generic.IEnumerable{``0},System.Int32) + M:MoreLinq.MoreEnumerable.MinBy``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1}) lib/netstandard2.1/MoreLinq.dll - lib/netstandard2.1/MoreLinq.dll - true - - - PKV006 - .NETStandard,Version=v1.0 + lib/net6.0/MoreLinq.dll diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index fea6ba41c..60ebd05e0 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -135,7 +135,7 @@ ..\dist README.md true - 3.4.1 + 4.0.0 true true true From 9a4ea61b5b5b15c7695bd846695a5a9aa84cf8f1 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 16 Nov 2023 23:04:27 +0100 Subject: [PATCH 124/157] Use .NET 8 SDK to add .NET 8 target This is a squashed merge of PR #1041. --------- Co-authored-by: Stuart Turner --- .editorconfig | 12 + Directory.Build.props | 2 +- MoreLinq.Test/.editorconfig | 3 + MoreLinq.Test/Make.cs | 30 + MoreLinq.Test/MemoizeTest.cs | 2 +- MoreLinq.Test/MoreLinq.Test.csproj | 2 +- MoreLinq.Test/OrderedMergeTest.cs | 2 - MoreLinq.Test/SegmentTest.cs | 2 - MoreLinq.Test/SliceTest.cs | 14 +- MoreLinq.Test/ZipLongestTest.cs | 8 +- MoreLinq/CompatibilitySuppressions.xml | 6 + MoreLinq/Experimental/Async/Merge.cs | 4 + MoreLinq/Experimental/Await.cs | 2 + MoreLinq/Flatten.cs | 3 +- MoreLinq/GroupAdjacent.cs | 2 +- MoreLinq/MoreLinq.csproj | 2 +- MoreLinq/Permutations.cs | 4 +- .../PublicAPI/net8.0/PublicAPI.Shipped.txt | 1 + .../PublicAPI/net8.0/PublicAPI.Unshipped.txt | 691 ++++++++++++++++++ MoreLinq/RandomSubset.cs | 3 + MoreLinq/SequenceException.cs | 18 +- MoreLinq/UnreachableException.cs | 8 +- appveyor.yml | 2 + .../MoreLinq.ExtensionsGenerator.csproj | 4 +- global.json | 2 +- test.cmd | 2 + test.sh | 2 +- 27 files changed, 802 insertions(+), 31 deletions(-) create mode 100644 MoreLinq.Test/Make.cs create mode 100644 MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt create mode 100644 MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt diff --git a/.editorconfig b/.editorconfig index 57e440765..bf62f14a8 100644 --- a/.editorconfig +++ b/.editorconfig @@ -86,3 +86,15 @@ dotnet_diagnostic.IDE0055.severity = suggestion # IDE0046: Convert to conditional expression dotnet_diagnostic.IDE0046.severity = suggestion + +# CA1510: Use 'ArgumentNullException.ThrowIfNull' instead of explicitly throwing a new exception instance +# TODO: Remove post https://github.com/morelinq/MoreLINQ/issues/903 +dotnet_diagnostic.CA1510.severity = suggestion + +# CA1512: Use 'ArgumentOutOfRangeException.ThrowIfNegativeOrZero' instead of explicitly throwing a new exception instance +# TODO: Remove post https://github.com/morelinq/MoreLINQ/issues/903 +dotnet_diagnostic.CA1512.severity = suggestion + +# CA1513: Use 'ObjectDisposedException.ThrowIf' instead of explicitly throwing a new exception instance +# TODO: Remove post https://github.com/morelinq/MoreLINQ/issues/903 +dotnet_diagnostic.CA1513.severity = suggestion diff --git a/Directory.Build.props b/Directory.Build.props index ef2ed08ed..9fc11a600 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -3,7 +3,7 @@ 11 enable true - 7.0-all + 8.0-all true EnableGenerateDocumentationFile diff --git a/MoreLinq.Test/.editorconfig b/MoreLinq.Test/.editorconfig index ffc9fb911..e6073bfb4 100644 --- a/MoreLinq.Test/.editorconfig +++ b/MoreLinq.Test/.editorconfig @@ -35,6 +35,9 @@ dotnet_diagnostic.IDE0047.severity = suggestion [*{Test,Tests}.cs] +# CA1861: Avoid constant arrays as arguments +dotnet_diagnostic.CA1861.severity = none + # IDE0022: Use expression/block body for methods dotnet_diagnostic.IDE0022.severity = none diff --git a/MoreLinq.Test/Make.cs b/MoreLinq.Test/Make.cs new file mode 100644 index 000000000..23e4cf873 --- /dev/null +++ b/MoreLinq.Test/Make.cs @@ -0,0 +1,30 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2018 Atif Aziz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +global using static MoreLinq.Test.Make; + +namespace MoreLinq.Test +{ + using System.Collections.Generic; + + static class Make + { + public static IEnumerable Seq(params T[] values) => + from value in values + select value; + } +} diff --git a/MoreLinq.Test/MemoizeTest.cs b/MoreLinq.Test/MemoizeTest.cs index 31ce2aeca..f8280e052 100644 --- a/MoreLinq.Test/MemoizeTest.cs +++ b/MoreLinq.Test/MemoizeTest.cs @@ -217,7 +217,7 @@ void Run() [Test] public static void MemoizeIteratorThrowsWhenCacheDisposedDuringIteration() { - var sequence = Enumerable.Range(1, 10); + var sequence = Seq(1, 2, 3); var memoized = sequence.Memoize(); var disposable = (IDisposable)memoized; diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index c30b247bb..0b6d42855 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -2,7 +2,7 @@ MoreLinq.Test - net7.0;net6.0;net471 + net8.0;net7.0;net6.0;net471 portable MoreLinq.Test Exe diff --git a/MoreLinq.Test/OrderedMergeTest.cs b/MoreLinq.Test/OrderedMergeTest.cs index 416e43c48..6efcc9574 100644 --- a/MoreLinq.Test/OrderedMergeTest.cs +++ b/MoreLinq.Test/OrderedMergeTest.cs @@ -24,8 +24,6 @@ namespace MoreLinq.Test [TestFixture] public class OrderedMergeTest { - static IEnumerable Seq(params T[] values) => values; - public static readonly IEnumerable TestData = from e in new[] { diff --git a/MoreLinq.Test/SegmentTest.cs b/MoreLinq.Test/SegmentTest.cs index e4b587120..0f8996d86 100644 --- a/MoreLinq.Test/SegmentTest.cs +++ b/MoreLinq.Test/SegmentTest.cs @@ -149,8 +149,6 @@ public void VerifyCanSegmentByPrevious() Assert.That(result.All(s => s.Count() == repCount), Is.True); } - static IEnumerable Seq(params T[] values) => values; - public static readonly IEnumerable TestData = from e in new[] { diff --git a/MoreLinq.Test/SliceTest.cs b/MoreLinq.Test/SliceTest.cs index d7498b946..f6b459f82 100644 --- a/MoreLinq.Test/SliceTest.cs +++ b/MoreLinq.Test/SliceTest.cs @@ -45,7 +45,7 @@ public void TestSliceIdentity() { const int count = 100; var sequenceA = Enumerable.Range(1, count); - var sequenceB = sequenceA.ToList(); + var sequenceB = sequenceA.ToList().AsEnumerable(); var resultA = sequenceA.Slice(0, count); var resultB = sequenceB.Slice(0, count); @@ -64,7 +64,8 @@ public void TestSliceFirstItem() { const int count = 10; var sequenceA = Enumerable.Range(1, count); - var sequenceB = sequenceA.ToList(); + var sequenceB = sequenceA.ToList().AsEnumerable(); + var resultA = sequenceA.Slice(0, 1); var resultB = sequenceB.Slice(0, 1); @@ -82,7 +83,8 @@ public void TestSliceLastItem() { const int count = 10; var sequenceA = Enumerable.Range(1, count); - var sequenceB = sequenceA.ToList(); + var sequenceB = sequenceA.ToList().AsEnumerable(); + var resultA = sequenceA.Slice(count - 1, 1); var resultB = sequenceB.Slice(count - 1, 1); @@ -101,7 +103,8 @@ public void TestSliceSmallerThanSequence() { const int count = 10; var sequenceA = Enumerable.Range(1, count); - var sequenceB = sequenceA.ToList(); + var sequenceB = sequenceA.ToList().AsEnumerable(); + var resultA = sequenceA.Slice(4, 5); var resultB = sequenceB.Slice(4, 5); @@ -120,7 +123,8 @@ public void TestSliceLongerThanSequence() { const int count = 100; var sequenceA = Enumerable.Range(1, count); - var sequenceB = sequenceA.ToList(); + var sequenceB = sequenceA.ToList().AsEnumerable(); + var resultA = sequenceA.Slice(count / 2, count); var resultB = sequenceB.Slice(count / 2, count); diff --git a/MoreLinq.Test/ZipLongestTest.cs b/MoreLinq.Test/ZipLongestTest.cs index 3d07993a5..6ead0148e 100644 --- a/MoreLinq.Test/ZipLongestTest.cs +++ b/MoreLinq.Test/ZipLongestTest.cs @@ -26,8 +26,6 @@ namespace MoreLinq.Test [TestFixture] public class ZipLongestTest { - static IEnumerable Seq(params T[] values) => values; - public static readonly IEnumerable TestData = from e in new[] { @@ -44,10 +42,10 @@ from e in new[] [Test, TestCaseSource(nameof(TestData))] - public IEnumerable<(int, string)> ZipLongest(int[] first, string[] second) + public IEnumerable<(int, string)> ZipLongest(IEnumerable first, IEnumerable second) { - using var ts1 = TestingSequence.Of(first); - using var ts2 = TestingSequence.Of(second); + using var ts1 = first.AsTestingSequence(); + using var ts2 = second.AsTestingSequence(); return ts1.ZipLongest(ts2, Tuple.Create).ToArray(); } diff --git a/MoreLinq/CompatibilitySuppressions.xml b/MoreLinq/CompatibilitySuppressions.xml index ffe9243dc..1b532b5f8 100644 --- a/MoreLinq/CompatibilitySuppressions.xml +++ b/MoreLinq/CompatibilitySuppressions.xml @@ -1,6 +1,12 @@ + + CP0002 + M:MoreLinq.SequenceException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) + lib/net6.0/MoreLinq.dll + lib/net8.0/MoreLinq.dll + CP0002 M:MoreLinq.MoreEnumerable.SkipLast``1(System.Collections.Generic.IEnumerable{``0},System.Int32) diff --git a/MoreLinq/Experimental/Async/Merge.cs b/MoreLinq/Experimental/Async/Merge.cs index 34130abef..7e6312b9b 100644 --- a/MoreLinq/Experimental/Async/Merge.cs +++ b/MoreLinq/Experimental/Async/Merge.cs @@ -180,7 +180,11 @@ async IAsyncEnumerable Async([EnumeratorCancellation]CancellationToken cancel // Signal cancellation to those in flight. Unfortunately, this relies on all // iterators to honour the cancellation. +#if NET8_0_OR_GREATER + await thisCancellationTokenSource.CancelAsync().ConfigureAwait(false); +#else thisCancellationTokenSource.Cancel(); +#endif // > The caller of an async-iterator method should only call `DisposeAsync()` // > when the method completed or was suspended by a `yield return`. diff --git a/MoreLinq/Experimental/Await.cs b/MoreLinq/Experimental/Await.cs index aa6e0a15f..abbfa0caa 100644 --- a/MoreLinq/Experimental/Await.cs +++ b/MoreLinq/Experimental/Await.cs @@ -697,7 +697,9 @@ await concurrencyGate.EnterAsync(cancellationToken) static class AwaitQuery { public static IAwaitQuery +#pragma warning disable CA1859 // Use concrete types when possible for improved performance (by-design) Create( +#pragma warning restore CA1859 // Use concrete types when possible for improved performance Func> impl, AwaitQueryOptions? options = null) => new AwaitQuery(impl, options); diff --git a/MoreLinq/Flatten.cs b/MoreLinq/Flatten.cs index 564da9731..eaee331d2 100644 --- a/MoreLinq/Flatten.cs +++ b/MoreLinq/Flatten.cs @@ -20,7 +20,6 @@ namespace MoreLinq { using System; - using System.Linq; using System.Collections; using System.Collections.Generic; @@ -135,7 +134,7 @@ public static IEnumerable< try { - while (stack.Any()) + while (stack.Count > 0) { e = stack.Pop(); diff --git a/MoreLinq/GroupAdjacent.cs b/MoreLinq/GroupAdjacent.cs index a79e58499..8cf89a5e3 100644 --- a/MoreLinq/GroupAdjacent.cs +++ b/MoreLinq/GroupAdjacent.cs @@ -295,7 +295,7 @@ static IEnumerable GroupAdjacentImpl( } } - static IGrouping CreateGroupAdjacentGrouping(TKey key, IList members) => + static Grouping CreateGroupAdjacentGrouping(TKey key, IList members) => Grouping.Create(key, members.IsReadOnly ? members : new ReadOnlyCollection(members)); static class Grouping diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 60ebd05e0..6671f4934 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -120,7 +120,7 @@ en-US 4.1.0 MoreLINQ Developers. - netstandard2.0;netstandard2.1;net6.0 + netstandard2.0;netstandard2.1;net6.0;net8.0 portable true MoreLinq diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs index 52e354c60..f6cb840c4 100644 --- a/MoreLinq/Permutations.cs +++ b/MoreLinq/Permutations.cs @@ -167,8 +167,8 @@ void NextPermutation() /// be surprised to discover that all of the permutations looked the /// same. /// - /// List of permuted source sequence values - IList PermuteValueSet() + /// Array of permuted source sequence values + T[] PermuteValueSet() { var permutedSet = new T[_permutation.Length]; for (var i = 0; i < _permutation.Length; i++) diff --git a/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt new file mode 100644 index 000000000..7dc5c5811 --- /dev/null +++ b/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt @@ -0,0 +1 @@ +#nullable enable diff --git a/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt new file mode 100644 index 000000000..ce7910980 --- /dev/null +++ b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt @@ -0,0 +1,691 @@ +#nullable enable +MoreLinq.Experimental.Async.ExperimentalEnumerable +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 +MoreLinq.Experimental.IAwaitQuery.Options.get -> MoreLinq.Experimental.AwaitQueryOptions! +MoreLinq.Experimental.IAwaitQuery.WithOptions(MoreLinq.Experimental.AwaitQueryOptions! options) -> MoreLinq.Experimental.IAwaitQuery! +MoreLinq.Experimental.ICurrentBuffer +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.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.MinByExtension +MoreLinq.Extensions.MaximaExtension +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 +MoreLinq.IExtremaEnumerable.Take(int count) -> System.Collections.Generic.IEnumerable! +MoreLinq.IExtremaEnumerable.TakeLast(int count) -> System.Collections.Generic.IEnumerable! +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) -> void +MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void +static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.Collections.Generic.IAsyncEnumerable! +static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.Collections.Generic.IAsyncEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential(this MoreLinq.Experimental.IAwaitQuery! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable!>! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator, System.Func!, TResult>! resultSelector) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Buffers.ArrayPool! pool, System.Func!, System.Collections.Generic.IEnumerable!>! bucketProjectionSelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Buffers.ArrayPool! pool, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency(this MoreLinq.Experimental.IAwaitQuery! source, int value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Memoize(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder(this MoreLinq.Experimental.IAwaitQuery! source, bool value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Scheduler(this MoreLinq.Experimental.IAwaitQuery! source, System.Threading.Tasks.TaskScheduler! value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many) -> (TCardinality Cardinality, T? Value) +static MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Extensions.AcquireExtension.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SkipUntilExtension.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SliceExtension.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeUntilExtension.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowRightExtension.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Unfold(TState state, System.Func! generator, System.Func! predicate, System.Func! stateSelector, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/RandomSubset.cs b/MoreLinq/RandomSubset.cs index d0716f57d..f5f0de015 100644 --- a/MoreLinq/RandomSubset.cs +++ b/MoreLinq/RandomSubset.cs @@ -76,8 +76,11 @@ static IEnumerable RandomSubsetImpl(IEnumerable source, Random rand, Fu if (array.Length < subsetSize) { +#pragma warning disable CA2208 // Instantiate argument exceptions correctly + // TODO Throw InvalidOperationException instead? throw new ArgumentOutOfRangeException(nameof(subsetSize), "Subset size must be less than or equal to the source length."); +#pragma warning restore CA2208 // Instantiate argument exceptions correctly } var m = 0; // keeps track of count items shuffled diff --git a/MoreLinq/SequenceException.cs b/MoreLinq/SequenceException.cs index c2226587b..6c5088984 100644 --- a/MoreLinq/SequenceException.cs +++ b/MoreLinq/SequenceException.cs @@ -18,14 +18,13 @@ namespace MoreLinq { using System; - using System.Runtime.Serialization; /// /// The exception that is thrown for a sequence that fails a condition. /// [Serializable] - public class SequenceException : Exception + public partial class SequenceException : Exception { const string DefaultMessage = "Error in sequence."; @@ -55,7 +54,20 @@ public SequenceException(string? message) : public SequenceException(string? message, Exception? innerException) : base(string.IsNullOrEmpty(message) ? DefaultMessage : message, innerException) { } + } +} +#if !NET7_0_OR_GREATER + +// BinaryFormatter serialization APIs are obsolete +// https://learn.microsoft.com/en-us/dotnet/core/compatibility/serialization/7.0/binaryformatter-apis-produce-errors + +namespace MoreLinq +{ + using System.Runtime.Serialization; + + partial class SequenceException + { /// /// Initializes a new instance of the class /// with serialized data. @@ -67,3 +79,5 @@ protected SequenceException(SerializationInfo info, StreamingContext context) : base(info, context) { } } } + +#endif // !NET8_0_OR_GREATER diff --git a/MoreLinq/UnreachableException.cs b/MoreLinq/UnreachableException.cs index 80e4cf0eb..137facb25 100644 --- a/MoreLinq/UnreachableException.cs +++ b/MoreLinq/UnreachableException.cs @@ -24,7 +24,11 @@ // SOFTWARE. #endregion -#if !NET7_0_OR_GREATER +#if NET7_0_OR_GREATER + +global using UnreachableException = System.Diagnostics.UnreachableException; + +#else namespace MoreLinq { @@ -55,4 +59,4 @@ public UnreachableException(string? message, Exception? innerException) : } } -#endif // !NET7_0_OR_GREATER +#endif // NET7_0_OR_GREATER diff --git a/appveyor.yml b/appveyor.yml index 27d35a0ad..98a25c24b 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -49,8 +49,10 @@ install: - git reset --hard - ps: if ($isWindows) { tools\dotnet-install.ps1 -JSonFile global.json } - ps: if ($isWindows) { tools\dotnet-install.ps1 -Runtime dotnet -Version 6.0.11 -SkipNonVersionedFiles } +- ps: if ($isWindows) { tools\dotnet-install.ps1 -Runtime dotnet -Version 7.0.14 -SkipNonVersionedFiles } - sh: ./tools/dotnet-install.sh --jsonfile global.json - sh: ./tools/dotnet-install.sh --runtime dotnet --version 6.0.11 --skip-non-versioned-files +- sh: ./tools/dotnet-install.sh --runtime dotnet --version 7.0.14 --skip-non-versioned-files - sh: export PATH="$HOME/.dotnet:$PATH" before_build: - dotnet --info diff --git a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj index e810d01e0..39132fd4d 100644 --- a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj +++ b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj @@ -1,12 +1,12 @@  Exe - net7.0 + net8.0 false - + diff --git a/global.json b/global.json index 5bf3e71b6..391ba3c2a 100644 --- a/global.json +++ b/global.json @@ -1,6 +1,6 @@ { "sdk": { - "version": "7.0.200", + "version": "8.0.100", "rollForward": "latestFeature" } } diff --git a/test.cmd b/test.cmd index 1cc6d54be..640f802b9 100644 --- a/test.cmd +++ b/test.cmd @@ -8,6 +8,8 @@ setlocal if not defined SKIP_TEST_BUILD set SKIP_TEST_BUILD=false if %SKIP_TEST_BUILD%==false call build || exit /b 1 call :clean ^ + && call :test net8.0 Debug ^ + && call :test net8.0 Release ^ && call :test net7.0 Debug ^ && call :test net7.0 Release ^ && call :test net6.0 Debug ^ diff --git a/test.sh b/test.sh index 2548482d1..fbe65fd50 100755 --- a/test.sh +++ b/test.sh @@ -12,7 +12,7 @@ if [[ -z "$1" ]]; then else configs="$1" fi -for f in net6.0 net7.0; do +for f in net6.0 net7.0 net8.0; do for c in $configs; do dotnet test --no-build -c $c -f $f --settings MoreLinq.Test/coverlet.runsettings MoreLinq.Test TEST_RESULTS_DIR="$(ls -dc MoreLinq.Test/TestResults/* | head -1)" From 80ab81c9e06af0409e621ddeef7f83e4f4ebf0b9 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Fri, 17 Nov 2023 19:12:34 +0100 Subject: [PATCH 125/157] Update to using C# 12 --- Directory.Build.props | 2 +- MoreLinq.Test/AppendTest.cs | 2 +- MoreLinq.Test/AssertCountTest.cs | 12 +--- MoreLinq.Test/AssertTest.cs | 5 +- MoreLinq.Test/Async/WatchableEnumerator.cs | 8 +-- MoreLinq.Test/BatchTest.cs | 2 +- MoreLinq.Test/BreakingCollection.cs | 6 +- MoreLinq.Test/BreakingList.cs | 7 +- MoreLinq.Test/BreakingReadOnlyCollection.cs | 7 +- MoreLinq.Test/BreakingReadOnlyList.cs | 8 +-- MoreLinq.Test/CountDownTest.cs | 40 +++++------- MoreLinq.Test/DistinctByTest.cs | 6 +- MoreLinq.Test/ExceptByTest.cs | 16 ++--- MoreLinq.Test/FlattenTest.cs | 30 +++------ MoreLinq.Test/GroupAdjacentTest.cs | 2 +- MoreLinq.Test/PermutationsTest.cs | 72 ++++++++++----------- MoreLinq.Test/PrependTest.cs | 6 +- MoreLinq.Test/ReadOnlyCollection.cs | 7 +- MoreLinq.Test/SequenceReader.cs | 18 ++---- MoreLinq.Test/SubsetTest.cs | 52 +++++++-------- MoreLinq.Test/TestException.cs | 3 +- MoreLinq.Test/ToDataTableTest.cs | 19 ++---- MoreLinq.Test/TransposeTest.cs | 54 ++++++++-------- MoreLinq.Test/TraverseTest.cs | 12 +--- MoreLinq.Test/TrySingleTest.cs | 16 ++--- MoreLinq.Test/WatchableEnumerator.cs | 8 +-- MoreLinq/Acquire.cs | 2 +- MoreLinq/Collections/Dictionary.cs | 10 ++- MoreLinq/CountBy.cs | 4 +- MoreLinq/Delegating.cs | 29 +++------ MoreLinq/EmptyArray.cs | 14 ---- MoreLinq/EquiZip.cs | 4 +- MoreLinq/Experimental/Async/Merge.cs | 6 +- MoreLinq/Experimental/Await.cs | 18 ++---- MoreLinq/Experimental/Batch.cs | 4 +- MoreLinq/Experimental/Memoize.cs | 12 +--- MoreLinq/FillBackward.cs | 2 +- MoreLinq/GroupAdjacent.cs | 15 ++--- MoreLinq/Maxima.cs | 28 +++----- MoreLinq/Partition.cs | 2 +- MoreLinq/PendNode.cs | 5 +- MoreLinq/Reactive/Subject.cs | 2 +- MoreLinq/Return.cs | 6 +- MoreLinq/ReverseComparer.cs | 7 +- MoreLinq/Segment.cs | 2 +- MoreLinq/SequenceException.cs | 2 + MoreLinq/SortedMerge.cs | 7 +- MoreLinq/Split.cs | 2 +- MoreLinq/ToArrayByIndex.cs | 4 +- MoreLinq/ToDataTable.cs | 2 +- bld/ExtensionsGenerator/Program.cs | 29 ++++----- 51 files changed, 260 insertions(+), 378 deletions(-) delete mode 100644 MoreLinq/EmptyArray.cs diff --git a/Directory.Build.props b/Directory.Build.props index 9fc11a600..222a1c0a6 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -1,6 +1,6 @@ - 11 + 12 enable true 8.0-all diff --git a/MoreLinq.Test/AppendTest.cs b/MoreLinq.Test/AppendTest.cs index 58dbd6c9d..0398a5658 100644 --- a/MoreLinq.Test/AppendTest.cs +++ b/MoreLinq.Test/AppendTest.cs @@ -37,7 +37,7 @@ public void AppendWithNonEmptyHeadSequence() [Test] public void AppendWithEmptyHeadSequence() { - string[] head = { }; + string[] head = []; var tail = "first"; var whole = head.Append(tail); whole.AssertSequenceEqual("first"); diff --git a/MoreLinq.Test/AssertCountTest.cs b/MoreLinq.Test/AssertCountTest.cs index b8dfe839d..05e5ae182 100644 --- a/MoreLinq.Test/AssertCountTest.cs +++ b/MoreLinq.Test/AssertCountTest.cs @@ -90,16 +90,10 @@ public void AssertCountShortSequenceWithErrorSelector() .And.Count.EqualTo(4)); } - sealed class TestException : Exception + sealed class TestException(int cmp, int count) : Exception { - public int Cmp { get; } - public int Count { get; } - - public TestException(int cmp, int count) - { - Cmp = cmp; - Count = count; - } + public int Cmp { get; } = cmp; + public int Count { get; } = count; } [Test] diff --git a/MoreLinq.Test/AssertTest.cs b/MoreLinq.Test/AssertTest.cs index ecd288ce6..ad037a030 100644 --- a/MoreLinq.Test/AssertTest.cs +++ b/MoreLinq.Test/AssertTest.cs @@ -63,10 +63,9 @@ public void AssertSequenceWithInvalidElementsAndCustomError() .With.Property(nameof(ValueException.Value)).EqualTo(7)); } - sealed class ValueException : Exception + sealed class ValueException(object value) : Exception { - public object Value { get; } - public ValueException(object value) => Value = value; + public object Value { get; } = value; } } } diff --git a/MoreLinq.Test/Async/WatchableEnumerator.cs b/MoreLinq.Test/Async/WatchableEnumerator.cs index 0920b36e2..e4635533f 100644 --- a/MoreLinq.Test/Async/WatchableEnumerator.cs +++ b/MoreLinq.Test/Async/WatchableEnumerator.cs @@ -26,16 +26,14 @@ partial class TestExtensions public static WatchableEnumerator AsWatchable(this IAsyncEnumerator source) => new(source); } - sealed class WatchableEnumerator : IAsyncEnumerator + sealed class WatchableEnumerator(IAsyncEnumerator source) : + IAsyncEnumerator { - readonly IAsyncEnumerator _source; + readonly IAsyncEnumerator _source = source ?? throw new ArgumentNullException(nameof(source)); public event EventHandler? Disposed; public event EventHandler? MoveNextCalled; - public WatchableEnumerator(IAsyncEnumerator source) => - _source = source ?? throw new ArgumentNullException(nameof(source)); - public T Current => _source.Current; public async ValueTask MoveNextAsync() diff --git a/MoreLinq.Test/BatchTest.cs b/MoreLinq.Test/BatchTest.cs index ee10acfb2..f755bc114 100644 --- a/MoreLinq.Test/BatchTest.cs +++ b/MoreLinq.Test/BatchTest.cs @@ -360,7 +360,7 @@ public void BatchBucketSelectorCurrentList() using var pool = new TestArrayPool(); int[]? bucketSelectorItems = null; - var result = input.Batch(4, pool, current => bucketSelectorItems = current.ToArray(), _ => 0); + var result = input.Batch(4, pool, current => bucketSelectorItems = [..current], _ => 0); using var reader = result.Read(); _ = reader.Read(); diff --git a/MoreLinq.Test/BreakingCollection.cs b/MoreLinq.Test/BreakingCollection.cs index 6cb4d03ed..8dda669cb 100644 --- a/MoreLinq.Test/BreakingCollection.cs +++ b/MoreLinq.Test/BreakingCollection.cs @@ -20,12 +20,12 @@ namespace MoreLinq.Test using System; using System.Collections.Generic; - class BreakingCollection : BreakingSequence, ICollection + class BreakingCollection(IList list) : + BreakingSequence, ICollection { - protected readonly IList List; + protected readonly IList List = list; public BreakingCollection(params T[] values) : this((IList)values) { } - public BreakingCollection(IList list) => List = list; public int Count => List.Count; diff --git a/MoreLinq.Test/BreakingList.cs b/MoreLinq.Test/BreakingList.cs index 5f054aba2..32673c6aa 100644 --- a/MoreLinq.Test/BreakingList.cs +++ b/MoreLinq.Test/BreakingList.cs @@ -28,10 +28,11 @@ namespace MoreLinq.Test /// expected to be lazily evaluated. /// - sealed class BreakingList : BreakingCollection, IList + sealed class BreakingList(List list) : + BreakingCollection(list), + IList { - public BreakingList() : this(new List()) { } - public BreakingList(List list) : base(list) { } + public BreakingList() : this([]) { } public int IndexOf(T item) => List.IndexOf(item); public void Insert(int index, T item) => throw new NotImplementedException(); diff --git a/MoreLinq.Test/BreakingReadOnlyCollection.cs b/MoreLinq.Test/BreakingReadOnlyCollection.cs index 9748e77ba..927a9f608 100644 --- a/MoreLinq.Test/BreakingReadOnlyCollection.cs +++ b/MoreLinq.Test/BreakingReadOnlyCollection.cs @@ -19,12 +19,13 @@ namespace MoreLinq.Test { using System.Collections.Generic; - class BreakingReadOnlyCollection : BreakingSequence, IReadOnlyCollection + class BreakingReadOnlyCollection(IReadOnlyCollection collection) : + BreakingSequence, IReadOnlyCollection { - readonly IReadOnlyCollection _collection; + readonly IReadOnlyCollection _collection = collection; public BreakingReadOnlyCollection(params T[] values) : this((IReadOnlyCollection)values) { } - public BreakingReadOnlyCollection(IReadOnlyCollection collection) => _collection = collection; + public int Count => _collection.Count; } } diff --git a/MoreLinq.Test/BreakingReadOnlyList.cs b/MoreLinq.Test/BreakingReadOnlyList.cs index 0e368c8aa..45c84963c 100644 --- a/MoreLinq.Test/BreakingReadOnlyList.cs +++ b/MoreLinq.Test/BreakingReadOnlyList.cs @@ -27,13 +27,13 @@ namespace MoreLinq.Test /// expected to be lazily evaluated. /// - sealed class BreakingReadOnlyList : BreakingReadOnlyCollection, IReadOnlyList + sealed class BreakingReadOnlyList(IReadOnlyList list) : + BreakingReadOnlyCollection(list), + IReadOnlyList { - readonly IReadOnlyList _list; + readonly IReadOnlyList _list = list; public BreakingReadOnlyList(params T[] values) : this((IReadOnlyList)values) { } - public BreakingReadOnlyList(IReadOnlyList list) : base(list) - => _list = list; public T this[int index] => _list[index]; } diff --git a/MoreLinq.Test/CountDownTest.cs b/MoreLinq.Test/CountDownTest.cs index b7c635667..1be4c6846 100644 --- a/MoreLinq.Test/CountDownTest.cs +++ b/MoreLinq.Test/CountDownTest.cs @@ -44,15 +44,15 @@ public void WithNegativeCount() static IEnumerable GetData(Func selector) { var xs = Enumerable.Range(0, 5).ToArray(); - yield return selector(xs, -1, new int?[] { null, null, null, null, null }); - yield return selector(xs, 0, new int?[] { null, null, null, null, null }); - yield return selector(xs, 1, new int?[] { null, null, null, null, 0 }); - yield return selector(xs, 2, new int?[] { null, null, null, 1, 0 }); - yield return selector(xs, 3, new int?[] { null, null, 2, 1, 0 }); - yield return selector(xs, 4, new int?[] { null, 3, 2, 1, 0 }); - yield return selector(xs, 5, new int?[] { 4, 3, 2, 1, 0 }); - yield return selector(xs, 6, new int?[] { 4, 3, 2, 1, 0 }); - yield return selector(xs, 7, new int?[] { 4, 3, 2, 1, 0 }); + yield return selector(xs, -1, [null, null, null, null, null]); + yield return selector(xs, 0, [null, null, null, null, null]); + yield return selector(xs, 1, [null, null, null, null, 0]); + yield return selector(xs, 2, [null, null, null, 1, 0]); + yield return selector(xs, 3, [null, null, 2, 1, 0]); + yield return selector(xs, 4, [null, 3, 2, 1, 0]); + yield return selector(xs, 5, [4, 3, 2, 1, 0]); + yield return selector(xs, 6, [4, 3, 2, 1, 0]); + yield return selector(xs, 7, [4, 3, 2, 1, 0]); } static readonly IEnumerable SequenceData = @@ -170,14 +170,11 @@ public IEnumerator GetEnumerator() => /// enumerator to be substituted for another. /// - sealed class Collection : Sequence, ICollection + sealed class Collection(ICollection collection, + Func, IEnumerator>? em = null) : + Sequence(em), ICollection { - readonly ICollection _collection; - - public Collection(ICollection collection, - Func, IEnumerator>? em = null) : - base(em) => - _collection = collection ?? throw new ArgumentNullException(nameof(collection)); + readonly ICollection _collection = collection ?? throw new ArgumentNullException(nameof(collection)); public int Count => _collection.Count; public bool IsReadOnly => _collection.IsReadOnly; @@ -197,14 +194,11 @@ public Collection(ICollection collection, /// also permits its enumerator to be substituted for another. /// - sealed class ReadOnlyCollection : Sequence, IReadOnlyCollection + sealed class ReadOnlyCollection(ICollection collection, + Func, IEnumerator>? em = null) : + Sequence(em), IReadOnlyCollection { - readonly ICollection _collection; - - public ReadOnlyCollection(ICollection collection, - Func, IEnumerator>? em = null) : - base(em) => - _collection = collection ?? throw new ArgumentNullException(nameof(collection)); + readonly ICollection _collection = collection ?? throw new ArgumentNullException(nameof(collection)); public int Count => _collection.Count; diff --git a/MoreLinq.Test/DistinctByTest.cs b/MoreLinq.Test/DistinctByTest.cs index 70c684592..d78c4614e 100644 --- a/MoreLinq.Test/DistinctByTest.cs +++ b/MoreLinq.Test/DistinctByTest.cs @@ -27,7 +27,7 @@ public class DistinctByTest [Test] public void DistinctBy() { - string[] source = { "first", "second", "third", "fourth", "fifth" }; + string[] source = ["first", "second", "third", "fourth", "fifth"]; var distinct = source.DistinctBy(word => word.Length); distinct.AssertSequenceEqual("first", "second"); } @@ -41,7 +41,7 @@ public void DistinctByIsLazy() [Test] public void DistinctByWithComparer() { - string[] source = { "first", "FIRST", "second", "second", "third" }; + string[] source = ["first", "FIRST", "second", "second", "third"]; var distinct = source.DistinctBy(word => word, StringComparer.OrdinalIgnoreCase); distinct.AssertSequenceEqual("first", "second", "third"); } @@ -49,7 +49,7 @@ public void DistinctByWithComparer() [Test] public void DistinctByNullComparer() { - string[] source = { "first", "second", "third", "fourth", "fifth" }; + string[] source = ["first", "second", "third", "fourth", "fifth"]; var distinct = source.DistinctBy(word => word.Length, null); distinct.AssertSequenceEqual("first", "second"); } diff --git a/MoreLinq.Test/ExceptByTest.cs b/MoreLinq.Test/ExceptByTest.cs index 43c3fa1a1..1935e0793 100644 --- a/MoreLinq.Test/ExceptByTest.cs +++ b/MoreLinq.Test/ExceptByTest.cs @@ -26,8 +26,8 @@ public class ExceptByTest [Test] public void SimpleExceptBy() { - string[] first = { "aaa", "bb", "c", "dddd" }; - string[] second = { "xx", "y" }; + string[] first = ["aaa", "bb", "c", "dddd"]; + string[] second = ["xx", "y"]; var result = first.ExceptBy(second, x => x.Length); result.AssertSequenceEqual("aaa", "dddd"); } @@ -42,8 +42,8 @@ public void ExceptByIsLazy() [Test] public void ExceptByDoesNotRepeatSourceElementsWithDuplicateKeys() { - string[] first = { "aaa", "bb", "c", "a", "b", "c", "dddd" }; - string[] second = { "xx" }; + string[] first = ["aaa", "bb", "c", "a", "b", "c", "dddd"]; + string[] second = ["xx"]; var result = first.ExceptBy(second, x => x.Length); result.AssertSequenceEqual("aaa", "c", "dddd"); } @@ -51,8 +51,8 @@ public void ExceptByDoesNotRepeatSourceElementsWithDuplicateKeys() [Test] public void ExceptByWithComparer() { - string[] first = { "first", "second", "third", "fourth" }; - string[] second = { "FIRST", "thiRD", "FIFTH" }; + string[] first = ["first", "second", "third", "fourth"]; + string[] second = ["FIRST", "thiRD", "FIFTH"]; var result = first.ExceptBy(second, word => word, StringComparer.OrdinalIgnoreCase); result.AssertSequenceEqual("second", "fourth"); } @@ -60,8 +60,8 @@ public void ExceptByWithComparer() [Test] public void ExceptByNullComparer() { - string[] first = { "aaa", "bb", "c", "dddd" }; - string[] second = { "xx", "y" }; + string[] first = ["aaa", "bb", "c", "dddd"]; + string[] second = ["xx", "y"]; var result = first.ExceptBy(second, x => x.Length, null); result.AssertSequenceEqual("aaa", "dddd"); } diff --git a/MoreLinq.Test/FlattenTest.cs b/MoreLinq.Test/FlattenTest.cs index f08a8f6fb..0ad6fd3a8 100644 --- a/MoreLinq.Test/FlattenTest.cs +++ b/MoreLinq.Test/FlattenTest.cs @@ -309,19 +309,19 @@ public void FlattenSelector() new Series { Name = "series1", - Attributes = new[] - { - new Attribute { Values = new[] { 1, 2 } }, - new Attribute { Values = new[] { 3, 4 } }, - } + Attributes = + [ + new Attribute { Values = [1, 2] }, + new Attribute { Values = [3, 4] }, + ] }, new Series { Name = "series2", - Attributes = new[] - { - new Attribute { Values = new[] { 5, 6 } }, - } + Attributes = + [ + new Attribute { Values = [5, 6] }, + ] } }; @@ -416,19 +416,9 @@ sealed class Attribute public required int[] Values; } - sealed class Tree + sealed record Tree(Tree? Left, T Value, Tree? Right) { - public readonly T Value; - public readonly Tree? Left; - public readonly Tree? Right; - public Tree(T value) : this(null, value, null) { } - public Tree(Tree? left, T value, Tree? right) - { - Left = left; - Value = value; - Right = right; - } } } } diff --git a/MoreLinq.Test/GroupAdjacentTest.cs b/MoreLinq.Test/GroupAdjacentTest.cs index b3830a2d2..223d60474 100644 --- a/MoreLinq.Test/GroupAdjacentTest.cs +++ b/MoreLinq.Test/GroupAdjacentTest.cs @@ -207,7 +207,7 @@ public void GroupAdjacentSourceSequenceWithSomeNullKeys() .SelectMany(x => Enumerable.Repeat((int?)x, x).Append(null)) .GroupAdjacent(x => x); - int?[] aNull = { null }; + int?[] aNull = [null]; using var reader = groupings.Read(); AssertGrouping(reader, 1, 1); diff --git a/MoreLinq.Test/PermutationsTest.cs b/MoreLinq.Test/PermutationsTest.cs index 892d3ea9b..44571c6fa 100644 --- a/MoreLinq.Test/PermutationsTest.cs +++ b/MoreLinq.Test/PermutationsTest.cs @@ -78,15 +78,15 @@ public void TestCardinalityThreePermutation() var set = new[] { 42, 11, 100 }; var permutations = set.Permutations(); - var expectedPermutations = new[] - { - new[] {42, 11, 100}, - new[] {42, 100, 11}, - new[] {11, 100, 42}, - new[] {11, 42, 100}, - new[] {100, 11, 42}, - new[] {100, 42, 11}, - }; + var expectedPermutations = new int[][] + { + [42, 11, 100], + [42, 100, 11], + [11, 100, 42], + [11, 42, 100], + [100, 11, 42], + [100, 42, 11], + }; // should contain six permutations (as defined above) Assert.That(permutations.Count(), Is.EqualTo(expectedPermutations.Length)); @@ -103,33 +103,33 @@ public void TestCardinalityFourPermutation() var set = new[] { 42, 11, 100, 89 }; var permutations = set.Permutations(); - var expectedPermutations = new[] - { - new[] {42, 11, 100, 89}, - new[] {42, 100, 11, 89}, - new[] {11, 100, 42, 89}, - new[] {11, 42, 100, 89}, - new[] {100, 11, 42, 89}, - new[] {100, 42, 11, 89}, - new[] {42, 11, 89, 100}, - new[] {42, 100, 89, 11}, - new[] {11, 100, 89, 42}, - new[] {11, 42, 89, 100}, - new[] {100, 11, 89, 42}, - new[] {100, 42, 89, 11}, - new[] {42, 89, 11, 100}, - new[] {42, 89, 100, 11}, - new[] {11, 89, 100, 42}, - new[] {11, 89, 42, 100}, - new[] {100, 89, 11, 42}, - new[] {100, 89, 42, 11}, - new[] {89, 42, 11, 100}, - new[] {89, 42, 100, 11}, - new[] {89, 11, 100, 42}, - new[] {89, 11, 42, 100}, - new[] {89, 100, 11, 42}, - new[] {89, 100, 42, 11}, - }; + var expectedPermutations = new int[][] + { + [42, 11, 100, 89], + [42, 100, 11, 89], + [11, 100, 42, 89], + [11, 42, 100, 89], + [100, 11, 42, 89], + [100, 42, 11, 89], + [42, 11, 89, 100], + [42, 100, 89, 11], + [11, 100, 89, 42], + [11, 42, 89, 100], + [100, 11, 89, 42], + [100, 42, 89, 11], + [42, 89, 11, 100], + [42, 89, 100, 11], + [11, 89, 100, 42], + [11, 89, 42, 100], + [100, 89, 11, 42], + [100, 89, 42, 11], + [89, 42, 11, 100], + [89, 42, 100, 11], + [89, 11, 100, 42], + [89, 11, 42, 100], + [89, 100, 11, 42], + [89, 100, 42, 11], + }; // should contain six permutations (as defined above) Assert.That(permutations.Count(), Is.EqualTo(expectedPermutations.Length)); diff --git a/MoreLinq.Test/PrependTest.cs b/MoreLinq.Test/PrependTest.cs index de8253f6e..00d5bf982 100644 --- a/MoreLinq.Test/PrependTest.cs +++ b/MoreLinq.Test/PrependTest.cs @@ -28,7 +28,7 @@ public class PrependTest [Test] public void PrependWithNonEmptyTailSequence() { - string[] tail = { "second", "third" }; + string[] tail = ["second", "third"]; var head = "first"; var whole = tail.Prepend(head); whole.AssertSequenceEqual("first", "second", "third"); @@ -37,7 +37,7 @@ public void PrependWithNonEmptyTailSequence() [Test] public void PrependWithEmptyTailSequence() { - string[] tail = { }; + string[] tail = []; var head = "first"; var whole = tail.Prepend(head); whole.AssertSequenceEqual("first"); @@ -46,7 +46,7 @@ public void PrependWithEmptyTailSequence() [Test] public void PrependWithNullHead() { - string[] tail = { "second", "third" }; + string[] tail = ["second", "third"]; string? head = null; var whole = tail.Prepend(head); whole.AssertSequenceEqual(null, "second", "third"); diff --git a/MoreLinq.Test/ReadOnlyCollection.cs b/MoreLinq.Test/ReadOnlyCollection.cs index 23da7f290..82004faf4 100644 --- a/MoreLinq.Test/ReadOnlyCollection.cs +++ b/MoreLinq.Test/ReadOnlyCollection.cs @@ -25,12 +25,11 @@ static class ReadOnlyCollection public static IReadOnlyCollection From(params T[] items) => new ListCollection(items); - sealed class ListCollection : IReadOnlyCollection + sealed class ListCollection(TList list) : + IReadOnlyCollection where TList : IList { - readonly TList _list; - - public ListCollection(TList list) => _list = list; + readonly TList _list = list; public IEnumerator GetEnumerator() => _list.GetEnumerator(); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); diff --git a/MoreLinq.Test/SequenceReader.cs b/MoreLinq.Test/SequenceReader.cs index 5a2a0cba6..c49c51c3b 100644 --- a/MoreLinq.Test/SequenceReader.cs +++ b/MoreLinq.Test/SequenceReader.cs @@ -35,9 +35,14 @@ public static SequenceReader Read(this IEnumerable source) /// "read" operation. /// /// Type of elements to read. - sealed class SequenceReader : IDisposable + /// + /// Initializes a instance + /// from an enumerator. + /// + /// Source enumerator. + sealed class SequenceReader(IEnumerator enumerator) : IDisposable { - IEnumerator? _enumerator; + IEnumerator? _enumerator = enumerator ?? throw new ArgumentNullException(nameof(enumerator)); /// /// Initializes a instance @@ -48,15 +53,6 @@ sealed class SequenceReader : IDisposable public SequenceReader(IEnumerable source) : this(GetEnumerator(source)) { } - /// - /// Initializes a instance - /// from an enumerator. - /// - /// Source enumerator. - - public SequenceReader(IEnumerator enumerator) => - _enumerator = enumerator ?? throw new ArgumentNullException(nameof(enumerator)); - static IEnumerator GetEnumerator(IEnumerable source) { if (source == null) throw new ArgumentNullException(nameof(source)); diff --git a/MoreLinq.Test/SubsetTest.cs b/MoreLinq.Test/SubsetTest.cs index 5b35524bf..ef079e166 100644 --- a/MoreLinq.Test/SubsetTest.cs +++ b/MoreLinq.Test/SubsetTest.cs @@ -117,14 +117,14 @@ public void TestAllSubsetsExpectedResults() var sequence = Enumerable.Range(1, 4); var result = sequence.Subsets(); - var expectedSubsets = new[] - { - new int[] {}, - new[] {1}, new[] {2}, new[] {3}, new[] {4}, - new[] {1,2}, new[] {1,3}, new[] {1,4}, new[] {2,3}, new[] {2,4}, new[] {3,4}, - new[] {1,2,3}, new[] {1,2,4}, new[] {1,3,4}, new[] {2,3,4}, - new[] {1,2,3,4} - }; + var expectedSubsets = new int[][] + { + [], + [1], [2], [3], [4], + [1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4], + [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4], + [1, 2, 3, 4] + }; var index = 0; foreach (var subset in result) @@ -170,24 +170,24 @@ public void TestKSubsetExpectedResult() var sequence = Enumerable.Range(1, 6); var result = sequence.Subsets(4); - var expectedSubsets = new[] - { - new[] {1,2,3,4}, - new[] {1,2,3,5}, - new[] {1,2,3,6}, - new[] {1,2,4,5}, - new[] {1,2,4,6}, - new[] {1,2,5,6}, - new[] {1,3,4,5}, - new[] {1,3,4,6}, - new[] {1,3,5,6}, - new[] {1,4,5,6}, - new[] {2,3,4,5}, - new[] {2,3,4,6}, - new[] {2,3,5,6}, - new[] {2,4,5,6}, - new[] {3,4,5,6}, - }; + var expectedSubsets = new int[][] + { + [1, 2, 3, 4], + [1, 2, 3, 5], + [1, 2, 3, 6], + [1, 2, 4, 5], + [1, 2, 4, 6], + [1, 2, 5, 6], + [1, 3, 4, 5], + [1, 3, 4, 6], + [1, 3, 5, 6], + [1, 4, 5, 6], + [2, 3, 4, 5], + [2, 3, 4, 6], + [2, 3, 5, 6], + [2, 4, 5, 6], + [3, 4, 5, 6], + }; var index = 0; foreach (var subset in result) diff --git a/MoreLinq.Test/TestException.cs b/MoreLinq.Test/TestException.cs index 98cb7c715..48f0cb740 100644 --- a/MoreLinq.Test/TestException.cs +++ b/MoreLinq.Test/TestException.cs @@ -21,9 +21,8 @@ namespace MoreLinq.Test /// Reserved for use within tests. /// - sealed class TestException : System.Exception + sealed class TestException(string? message) : System.Exception(message) { public TestException() : this(null) { } - public TestException(string? message) : base(message) { } } } diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs index ae053830c..5842fe23a 100644 --- a/MoreLinq.Test/ToDataTableTest.cs +++ b/MoreLinq.Test/ToDataTableTest.cs @@ -27,26 +27,17 @@ namespace MoreLinq.Test [TestFixture] public class ToDataTableTest { - sealed class TestObject + sealed class TestObject(int key) { - public int KeyField; - public Guid? ANullableGuidField; + public int KeyField = key; + public Guid? ANullableGuidField = Guid.NewGuid(); - public string AString { get; } - public decimal? ANullableDecimal { get; } + public string AString { get; } = "ABCDEFGHIKKLMNOPQRSTUVWXYSZ"; + public decimal? ANullableDecimal { get; } = key / 3; public object Unreadable { set => throw new NotImplementedException(); } public object this[int index] { get => new(); set { } } - public TestObject(int key) - { - KeyField = key; - ANullableGuidField = Guid.NewGuid(); - - ANullableDecimal = key / 3; - AString = "ABCDEFGHIKKLMNOPQRSTUVWXYSZ"; - } - public override string ToString() => nameof(TestObject); } diff --git a/MoreLinq.Test/TransposeTest.cs b/MoreLinq.Test/TransposeTest.cs index 826e55687..2e1cf417d 100644 --- a/MoreLinq.Test/TransposeTest.cs +++ b/MoreLinq.Test/TransposeTest.cs @@ -45,12 +45,12 @@ public void TransposeWithOneNullRow() [Test] public void TransposeWithRowsOfSameLength() { - var expectations = new[] + var expectations = new int[][] { - new [] { 10, 20, 30 }, - new [] { 11, 21, 31 }, - new [] { 12, 22, 32 }, - new [] { 13, 23, 33 }, + [10, 20, 30], + [11, 21, 31], + [12, 22, 32], + [13, 23, 33], }; using var row1 = TestingSequence.Of(10, 11, 12, 13); @@ -64,11 +64,11 @@ public void TransposeWithRowsOfSameLength() [Test] public void TransposeWithRowsOfDifferentLengths() { - var expectations = new[] + var expectations = new int[][] { - new[] { 10, 20, 30 }, - new[] { 11, 31 }, - new[] { 32 } + [10, 20, 30], + [11, 31], + [32] }; using var row1 = TestingSequence.Of(10, 11); @@ -85,10 +85,10 @@ public void TransposeMaintainsCornerElements() { var matrix = new[] { - new[] { 10, 11 }, - new[] { 20 }, + [10, 11], + [20], new int[0], - new[] { 30, 31, 32 } + [30, 31, 32] }; var traspose = matrix.Transpose(); @@ -107,13 +107,13 @@ public void TransposeWithAllRowsAsInfiniteSequences() var result = matrix.Transpose().Take(5); - var expectations = new[] + var expectations = new int[][] { - new[] { 2, 3, 5 }, - new[] { 4, 9, 25 }, - new[] { 8, 27, 125 }, - new[] { 16, 81, 625 }, - new[] { 32, 243, 3125 } + [2, 3, 5], + [4, 9, 25], + [8, 27, 125], + [16, 81, 625], + [32, 243, 3125] }; AssertMatrix(expectations, result); @@ -130,13 +130,13 @@ public void TransposeWithSomeRowsAsInfiniteSequences() var result = matrix.Transpose().Take(5); - var expectations = new[] + var expectations = new int[][] { - new[] { 2, 3, 5 }, - new[] { 4, 9, 25 }, - new[] { 8, 125 }, - new[] { 16, 625 }, - new[] { 32, 3125 } + [2, 3, 5], + [4, 9, 25], + [8, 125], + [16, 625], + [32, 3125] }; AssertMatrix(expectations, result); @@ -147,10 +147,10 @@ public void TransposeColumnTraversalOrderIsIrrelevant() { var matrix = new[] { - new[] { 10, 11 }, - new[] { 20 }, + [10, 11], + [20], new int[0], - new[] { 30, 31, 32 } + [30, 31, 32] }; var transpose = matrix.Transpose().ToList(); diff --git a/MoreLinq.Test/TraverseTest.cs b/MoreLinq.Test/TraverseTest.cs index 163b3b401..89a0b2277 100644 --- a/MoreLinq.Test/TraverseTest.cs +++ b/MoreLinq.Test/TraverseTest.cs @@ -50,16 +50,10 @@ public void TraverseBreadthFirstPreservesChildrenOrder() res.AssertSequenceEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10); } - sealed class Tree + sealed class Tree(T value, IEnumerable> children) { - public T Value { get; } - public IEnumerable> Children { get; } - - public Tree(T value, IEnumerable> children) - { - Value = value; - Children = children; - } + public T Value { get; } = value; + public IEnumerable> Children { get; } = children; } static class Tree diff --git a/MoreLinq.Test/TrySingleTest.cs b/MoreLinq.Test/TrySingleTest.cs index 45186c623..01b12b313 100644 --- a/MoreLinq.Test/TrySingleTest.cs +++ b/MoreLinq.Test/TrySingleTest.cs @@ -65,10 +65,10 @@ public void TrySingleWithSingletonCollection(IEnumerable source, T result) } static readonly ITestCaseData[] SingletonCollectionTestCases = - { + [ new TestCaseData(new BreakingSingleElementCollection(10), 10), new TestCaseData(new BreakingSingleElementReadOnlyCollection(20), 20) - }; + ]; class BreakingSingleElementCollectionBase : IEnumerable { @@ -89,11 +89,10 @@ public IEnumerator GetEnumerator() IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } - sealed class BreakingSingleElementCollection : - BreakingSingleElementCollectionBase, ICollection + sealed class BreakingSingleElementCollection(T element) : + BreakingSingleElementCollectionBase(element), + ICollection { - public BreakingSingleElementCollection(T element) : base(element) { } - public void Add(T item) => throw new NotImplementedException(); public void Clear() => throw new NotImplementedException(); public bool Contains(T item) => throw new NotImplementedException(); @@ -102,10 +101,9 @@ public BreakingSingleElementCollection(T element) : base(element) { } public bool IsReadOnly => true; } - sealed class BreakingSingleElementReadOnlyCollection : - BreakingSingleElementCollectionBase, IReadOnlyCollection + sealed class BreakingSingleElementReadOnlyCollection(T element) : + BreakingSingleElementCollectionBase(element), IReadOnlyCollection { - public BreakingSingleElementReadOnlyCollection(T element) : base(element) { } } [TestCase(SourceKind.Sequence)] diff --git a/MoreLinq.Test/WatchableEnumerator.cs b/MoreLinq.Test/WatchableEnumerator.cs index 4cb3d4221..2d782604d 100644 --- a/MoreLinq.Test/WatchableEnumerator.cs +++ b/MoreLinq.Test/WatchableEnumerator.cs @@ -26,17 +26,15 @@ partial class TestExtensions public static WatchableEnumerator AsWatchable(this IEnumerator source) => new(source); } - sealed class WatchableEnumerator : IEnumerator + sealed class WatchableEnumerator(IEnumerator source) : + IEnumerator { - readonly IEnumerator _source; + readonly IEnumerator _source = source ?? throw new ArgumentNullException(nameof(source)); public event EventHandler? Disposed; public event EventHandler? GetCurrentCalled; public event EventHandler? MoveNextCalled; - public WatchableEnumerator(IEnumerator source) => - _source = source ?? throw new ArgumentNullException(nameof(source)); - public T Current { get diff --git a/MoreLinq/Acquire.cs b/MoreLinq/Acquire.cs index d7e44900f..6b3d47121 100644 --- a/MoreLinq/Acquire.cs +++ b/MoreLinq/Acquire.cs @@ -47,7 +47,7 @@ public static TSource[] Acquire(this IEnumerable source) try { disposables.AddRange(source); - return disposables.ToArray(); + return [..disposables]; } catch { diff --git a/MoreLinq/Collections/Dictionary.cs b/MoreLinq/Collections/Dictionary.cs index a325768d8..f79b23104 100644 --- a/MoreLinq/Collections/Dictionary.cs +++ b/MoreLinq/Collections/Dictionary.cs @@ -49,13 +49,11 @@ public TValue this[TKey key] public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value) => _dict.TryGetValue(ValueTuple.Create(key), out value); - sealed class ValueTupleItemComparer : IEqualityComparer> + sealed class ValueTupleItemComparer(IEqualityComparer comparer) : + IEqualityComparer> { - readonly IEqualityComparer _comparer; - - public ValueTupleItemComparer(IEqualityComparer comparer) => _comparer = comparer; - public bool Equals(ValueTuple x, ValueTuple y) => _comparer.Equals(x.Item1, y.Item1); - public int GetHashCode(ValueTuple obj) => obj.Item1 is { } some ? _comparer.GetHashCode(some) : 0; + public bool Equals(ValueTuple x, ValueTuple y) => comparer.Equals(x.Item1, y.Item1); + public int GetHashCode(ValueTuple obj) => obj.Item1 is { } some ? comparer.GetHashCode(some) : 0; } } } diff --git a/MoreLinq/CountBy.cs b/MoreLinq/CountBy.cs index 282ace5d4..c1f8873ed 100644 --- a/MoreLinq/CountBy.cs +++ b/MoreLinq/CountBy.cs @@ -80,8 +80,8 @@ void Loop(IEqualityComparer cmp) { var dic = new Collections.Dictionary(cmp); - keys = new List(); - counts = new List(); + keys = []; + counts = []; foreach (var item in source) { diff --git a/MoreLinq/Delegating.cs b/MoreLinq/Delegating.cs index 9b427e6c5..81c9ada81 100644 --- a/MoreLinq/Delegating.cs +++ b/MoreLinq/Delegating.cs @@ -40,12 +40,9 @@ public static IObserver Observer(Action onNext, new DelegatingObserver(onNext, onError, onCompleted); } - sealed class DelegatingDisposable : IDisposable + sealed class DelegatingDisposable(Action delegatee) : IDisposable { - Action? _delegatee; - - public DelegatingDisposable(Action delegatee) => - _delegatee = delegatee ?? throw new ArgumentNullException(nameof(delegatee)); + Action? _delegatee = delegatee ?? throw new ArgumentNullException(nameof(delegatee)); public void Dispose() { @@ -56,23 +53,15 @@ public void Dispose() } } - sealed class DelegatingObserver : IObserver + sealed class DelegatingObserver(Action onNext, + Action? onError = null, + Action? onCompleted = null) : + IObserver { - readonly Action _onNext; - readonly Action? _onError; - readonly Action? _onCompleted; - - public DelegatingObserver(Action onNext, - Action? onError = null, - Action? onCompleted = null) - { - _onNext = onNext ?? throw new ArgumentNullException(nameof(onNext)); - _onError = onError; - _onCompleted = onCompleted; - } + readonly Action _onNext = onNext ?? throw new ArgumentNullException(nameof(onNext)); - public void OnCompleted() => _onCompleted?.Invoke(); - public void OnError(Exception error) => _onError?.Invoke(error); + public void OnCompleted() => onCompleted?.Invoke(); + public void OnError(Exception error) => onError?.Invoke(error); public void OnNext(T value) => _onNext(value); } } diff --git a/MoreLinq/EmptyArray.cs b/MoreLinq/EmptyArray.cs deleted file mode 100644 index fa49b3567..000000000 --- a/MoreLinq/EmptyArray.cs +++ /dev/null @@ -1,14 +0,0 @@ -namespace MoreLinq -{ - static class EmptyArray - { - public static readonly T[] Value = -#if NETSTANDARD1_6_OR_GREATER || NET6_0_OR_GREATER - System.Array.Empty(); -#else -#pragma warning disable CA1825 // Avoid zero-length array allocations - new T[0]; -#pragma warning restore CA1825 // Avoid zero-length array allocations -#endif - } -} diff --git a/MoreLinq/EquiZip.cs b/MoreLinq/EquiZip.cs index 61212f122..7417e17e2 100644 --- a/MoreLinq/EquiZip.cs +++ b/MoreLinq/EquiZip.cs @@ -201,7 +201,7 @@ static IEnumerable EquiZipImpl( } static readonly string[] OrdinalNumbers = - { + [ "First", "Second", "Third", @@ -218,6 +218,6 @@ static IEnumerable EquiZipImpl( // "Fourteenth", // "Fifteenth", // "Sixteenth", - }; + ]; } } diff --git a/MoreLinq/Experimental/Async/Merge.cs b/MoreLinq/Experimental/Async/Merge.cs index 7e6312b9b..72c9a459c 100644 --- a/MoreLinq/Experimental/Async/Merge.cs +++ b/MoreLinq/Experimental/Async/Merge.cs @@ -107,7 +107,7 @@ async IAsyncEnumerable Async([EnumeratorCancellation]CancellationToken cancel enumeratorList.AddRange(from s in sources select s.GetAsyncEnumerator(cancellationToken)); - pendingTaskList = new List)>>(); + pendingTaskList = []; const bool some = true; @@ -117,7 +117,7 @@ async IAsyncEnumerable Async([EnumeratorCancellation]CancellationToken cancel var disposalTask = enumerator.DisposeAsync(); if (disposalTask.IsCompleted) return disposalTask; - disposalTaskList ??= new List(); + disposalTaskList ??= []; disposalTaskList.Add(disposalTask.AsTask()); return null; } @@ -232,7 +232,7 @@ async IAsyncEnumerable Async([EnumeratorCancellation]CancellationToken cancel } else { - disposalTaskList ??= new List(); + disposalTaskList ??= []; disposalTaskList.Add(task.AsTask()); } } diff --git a/MoreLinq/Experimental/Await.cs b/MoreLinq/Experimental/Await.cs index abbfa0caa..c7d1919f6 100644 --- a/MoreLinq/Experimental/Await.cs +++ b/MoreLinq/Experimental/Await.cs @@ -705,26 +705,18 @@ public static IAwaitQuery new AwaitQuery(impl, options); } - sealed class AwaitQuery : IAwaitQuery + sealed class AwaitQuery(Func> impl, + AwaitQueryOptions? options = null) : IAwaitQuery { - readonly Func> _impl; - - public AwaitQuery(Func> impl, - AwaitQueryOptions? options = null) - { - _impl = impl; - Options = options ?? AwaitQueryOptions.Default; - } - - public AwaitQueryOptions Options { get; } + public AwaitQueryOptions Options { get; } = options ?? AwaitQueryOptions.Default; public IAwaitQuery WithOptions(AwaitQueryOptions options) { if (options == null) throw new ArgumentNullException(nameof(options)); - return Options == options ? this : new AwaitQuery(_impl, options); + return Options == options ? this : new AwaitQuery(impl, options); } - public IEnumerator GetEnumerator() => _impl(Options).GetEnumerator(); + public IEnumerator GetEnumerator() => impl(Options).GetEnumerator(); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } diff --git a/MoreLinq/Experimental/Batch.cs b/MoreLinq/Experimental/Batch.cs index ee25e1619..f4cae14be 100644 --- a/MoreLinq/Experimental/Batch.cs +++ b/MoreLinq/Experimental/Batch.cs @@ -229,7 +229,7 @@ ICurrentBufferProvider Cursor(IEnumerator<(T[], int)> source) => sealed class CurrentPoolArrayProvider : CurrentBuffer, ICurrentBufferProvider { bool _rented; - T[] _array = Array.Empty(); + T[] _array = []; int _count; IEnumerator<(T[], int)>? _rental; ArrayPool? _pool; @@ -280,7 +280,7 @@ public void Dispose() if (_rented) _pool.Return(array); enumerator.Dispose(); - _array = Array.Empty(); + _array = []; _count = 0; _rental = null; _pool = null; diff --git a/MoreLinq/Experimental/Memoize.cs b/MoreLinq/Experimental/Memoize.cs index 258037e9c..d7ee0f7ab 100644 --- a/MoreLinq/Experimental/Memoize.cs +++ b/MoreLinq/Experimental/Memoize.cs @@ -62,21 +62,15 @@ public static IEnumerable Memoize(this IEnumerable source) => }; } - sealed class MemoizedEnumerable : IEnumerable, IDisposable + sealed class MemoizedEnumerable(IEnumerable sequence) : IEnumerable, IDisposable { List? _cache; - readonly object _locker; - readonly IEnumerable _source; + readonly object _locker = new(); + readonly IEnumerable _source = sequence ?? throw new ArgumentNullException(nameof(sequence)); IEnumerator? _sourceEnumerator; int? _errorIndex; ExceptionDispatchInfo? _error; - public MemoizedEnumerable(IEnumerable sequence) - { - _source = sequence ?? throw new ArgumentNullException(nameof(sequence)); - _locker = new object(); - } - public IEnumerator GetEnumerator() { if (_cache == null) diff --git a/MoreLinq/FillBackward.cs b/MoreLinq/FillBackward.cs index c07c8a81b..639f1d450 100644 --- a/MoreLinq/FillBackward.cs +++ b/MoreLinq/FillBackward.cs @@ -114,7 +114,7 @@ static IEnumerable FillBackwardImpl(IEnumerable source, Func p var isBlank = predicate(item); if (isBlank) { - (blanks ??= new List()).Add(item); + (blanks ??= []).Add(item); } else { diff --git a/MoreLinq/GroupAdjacent.cs b/MoreLinq/GroupAdjacent.cs index 8cf89a5e3..fe6043f82 100644 --- a/MoreLinq/GroupAdjacent.cs +++ b/MoreLinq/GroupAdjacent.cs @@ -305,19 +305,12 @@ public static Grouping Create(TKey key, IEnumera } [Serializable] - sealed class Grouping : IGrouping + sealed class Grouping(TKey key, IEnumerable members) : + IGrouping { - readonly IEnumerable _members; + public TKey Key { get; } = key; - public Grouping(TKey key, IEnumerable members) - { - Key = key; - _members = members; - } - - public TKey Key { get; } - - public IEnumerator GetEnumerator() => _members.GetEnumerator(); + public IEnumerator GetEnumerator() => members.GetEnumerator(); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } } diff --git a/MoreLinq/Maxima.cs b/MoreLinq/Maxima.cs index 60150a433..d5262251b 100644 --- a/MoreLinq/Maxima.cs +++ b/MoreLinq/Maxima.cs @@ -218,21 +218,13 @@ public static IExtremaEnumerable Maxima(this IEnumerable return new ExtremaEnumerable(source, selector, comparer.Compare); } - sealed class ExtremaEnumerable : IExtremaEnumerable + sealed class ExtremaEnumerable(IEnumerable source, + Func selector, + Func comparer) : + IExtremaEnumerable { - readonly IEnumerable _source; - readonly Func _selector; - readonly Func _comparer; - - public ExtremaEnumerable(IEnumerable source, Func selector, Func comparer) - { - _source = source; - _selector = selector; - _comparer = comparer; - } - public IEnumerator GetEnumerator() => - ExtremaBy(_source, Extrema.First, null, _selector, _comparer).GetEnumerator(); + ExtremaBy(source, Extrema.First, null, selector, comparer).GetEnumerator(); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); @@ -241,16 +233,16 @@ public IEnumerable Take(int count) => count switch { 0 => Enumerable.Empty(), - 1 => ExtremaBy(_source, Extremum.First, 1 , _selector, _comparer), - _ => ExtremaBy(_source, Extrema.First , count, _selector, _comparer) + 1 => ExtremaBy(source, Extremum.First, 1 , selector, comparer), + _ => ExtremaBy(source, Extrema.First , count, selector, comparer) }; public IEnumerable TakeLast(int count) => count switch { 0 => Enumerable.Empty(), - 1 => ExtremaBy(_source, Extremum.Last, 1 , _selector, _comparer), - _ => ExtremaBy(_source, Extrema.Last , count, _selector, _comparer) + 1 => ExtremaBy(source, Extremum.Last, 1 , selector, comparer), + _ => ExtremaBy(source, Extrema.Last , count, selector, comparer) }; static class Extrema @@ -267,7 +259,7 @@ sealed class FirstExtrema : Extrema?, T> public override void Add(ref List? store, int? limit, T item) { if (limit == null || store is null || store.Count < limit) - (store ??= new List()).Add(item); + (store ??= []).Add(item); } } diff --git a/MoreLinq/Partition.cs b/MoreLinq/Partition.cs index aa72f8725..9660186fc 100644 --- a/MoreLinq/Partition.cs +++ b/MoreLinq/Partition.cs @@ -367,7 +367,7 @@ static TResult PartitionImpl(IEnumerable>(); + etc ??= []; etc.Add(e); } else diff --git a/MoreLinq/PendNode.cs b/MoreLinq/PendNode.cs index 2bf363863..9c3e4e5f5 100644 --- a/MoreLinq/PendNode.cs +++ b/MoreLinq/PendNode.cs @@ -53,10 +53,9 @@ public Item(T item, bool isPrepend, PendNode next) } } - sealed class Source : PendNode + sealed class Source(IEnumerable source) : PendNode { - public IEnumerable Value { get; } - public Source(IEnumerable source) => Value = source; + public IEnumerable Value { get; } = source; } public IEnumerator GetEnumerator() diff --git a/MoreLinq/Reactive/Subject.cs b/MoreLinq/Reactive/Subject.cs index 145282cf0..40f2ed6d2 100644 --- a/MoreLinq/Reactive/Subject.cs +++ b/MoreLinq/Reactive/Subject.cs @@ -28,7 +28,7 @@ sealed class Subject : IObservable, IObserver Exception? _error; bool HasObservers => (_observers?.Count ?? 0) > 0; - List> Observers => _observers ??= new List>(); + List> Observers => _observers ??= []; bool IsMuted => _completed || _error != null; diff --git a/MoreLinq/Return.cs b/MoreLinq/Return.cs index 35ffa3adc..078d5beb7 100644 --- a/MoreLinq/Return.cs +++ b/MoreLinq/Return.cs @@ -32,11 +32,9 @@ partial class MoreEnumerable public static IEnumerable Return(T item) => new SingleElementList(item); - sealed class SingleElementList : IList, IReadOnlyList + sealed class SingleElementList(T item) : IList, IReadOnlyList { - readonly T _item; - - public SingleElementList(T item) => _item = item; + readonly T _item = item; public int Count => 1; public bool IsReadOnly => true; diff --git a/MoreLinq/ReverseComparer.cs b/MoreLinq/ReverseComparer.cs index 63fbf527f..e80749bcd 100644 --- a/MoreLinq/ReverseComparer.cs +++ b/MoreLinq/ReverseComparer.cs @@ -19,12 +19,9 @@ namespace MoreLinq { using System.Collections.Generic; - sealed class ReverseComparer : IComparer + sealed class ReverseComparer(IComparer? underlying) : IComparer { - readonly IComparer _underlying; - - public ReverseComparer(IComparer? underlying) => - _underlying = underlying ?? Comparer.Default; + readonly IComparer _underlying = underlying ?? Comparer.Default; public int Compare #if NETCOREAPP3_1_OR_GREATER diff --git a/MoreLinq/Segment.cs b/MoreLinq/Segment.cs index 788aa3ae7..859f59014 100644 --- a/MoreLinq/Segment.cs +++ b/MoreLinq/Segment.cs @@ -95,7 +95,7 @@ public static IEnumerable> Segment(this IEnumerable source, if (newSegmentPredicate(current, previous, index)) { yield return segment; // yield the completed segment - segment = new List { current }; // start a new segment + segment = [current]; // start a new segment } else // not a new segment, append and continue { diff --git a/MoreLinq/SequenceException.cs b/MoreLinq/SequenceException.cs index 6c5088984..11ac75b31 100644 --- a/MoreLinq/SequenceException.cs +++ b/MoreLinq/SequenceException.cs @@ -52,7 +52,9 @@ public SequenceException(string? message) : /// A message that describes the error. /// The exception that is the cause of the current exception. +#pragma warning disable IDE0290 // Use primary constructor (needed due to deserialization constructor) public SequenceException(string? message, Exception? innerException) : +#pragma warning restore IDE0290 // Use primary constructor base(string.IsNullOrEmpty(message) ? DefaultMessage : message, innerException) { } } } diff --git a/MoreLinq/SortedMerge.cs b/MoreLinq/SortedMerge.cs index 9f6aff425..03757dcb5 100644 --- a/MoreLinq/SortedMerge.cs +++ b/MoreLinq/SortedMerge.cs @@ -156,12 +156,9 @@ IEnumerable Impl(IEnumerable> sequences) /// are disposed - either when Excluded or when the DisposableGroup is disposed. /// - sealed class DisposableGroup : IDisposable + sealed class DisposableGroup(IEnumerable> iterators) : IDisposable { - public DisposableGroup(IEnumerable> iterators) => - Iterators = new List>(iterators); - - public List> Iterators { get; } + public List> Iterators { get; } = new(iterators); public IEnumerator this[int index] => Iterators[index]; diff --git a/MoreLinq/Split.cs b/MoreLinq/Split.cs index 1e101be66..935537aa5 100644 --- a/MoreLinq/Split.cs +++ b/MoreLinq/Split.cs @@ -287,7 +287,7 @@ public static IEnumerable Split(this IEnumerable(); + items ??= []; items.Add(item); } } diff --git a/MoreLinq/ToArrayByIndex.cs b/MoreLinq/ToArrayByIndex.cs index ce7c5917f..b450d0be5 100644 --- a/MoreLinq/ToArrayByIndex.cs +++ b/MoreLinq/ToArrayByIndex.cs @@ -122,7 +122,7 @@ public static TResult[] ToArrayByIndex(this IEnumerable source, var lastIndex = -1; var indexed = (List>?)null; - List> Indexed() => indexed ??= new List>(); + List> Indexed() => indexed ??= []; foreach (var e in source) { @@ -143,7 +143,7 @@ public static TResult[] ToArrayByIndex(this IEnumerable source, var length = lastIndex + 1; return length == 0 - ? EmptyArray.Value + ? [] : Indexed().ToArrayByIndex(length, e => e.Key, e => resultSelector(e.Value, e.Key)); } diff --git a/MoreLinq/ToDataTable.cs b/MoreLinq/ToDataTable.cs index 08027567c..ba2275956 100644 --- a/MoreLinq/ToDataTable.cs +++ b/MoreLinq/ToDataTable.cs @@ -41,7 +41,7 @@ static partial class MoreEnumerable public static TTable ToDataTable(this IEnumerable source, TTable table) where TTable : DataTable { - return ToDataTable(source, table, EmptyArray>>.Value); + return ToDataTable(source, table, []); } /// diff --git a/bld/ExtensionsGenerator/Program.cs b/bld/ExtensionsGenerator/Program.cs index 762eae7e7..35dae759d 100644 --- a/bld/ExtensionsGenerator/Program.cs +++ b/bld/ExtensionsGenerator/Program.cs @@ -380,9 +380,8 @@ protected static int Compare(IEnumerable a, IEnumerable b) => .FirstOrDefault(e => e != 0); } -sealed class SimpleTypeKey : TypeKey +sealed class SimpleTypeKey(string name) : TypeKey(name) { - public SimpleTypeKey(string name) : base(name) { } public override string ToString() => Name; public override ImmutableList Parameters => ImmutableList.Empty; } @@ -390,7 +389,7 @@ public SimpleTypeKey(string name) : base(name) { } abstract class ParameterizedTypeKey : TypeKey { protected ParameterizedTypeKey(string name, TypeKey parameter) : - this(name, ImmutableList.Create(parameter)) { } + this(name, [parameter]) { } protected ParameterizedTypeKey(string name, ImmutableList parameters) : base(name) => Parameters = parameters; @@ -398,36 +397,30 @@ protected ParameterizedTypeKey(string name, ImmutableList parameters) : public override ImmutableList Parameters { get; } } -sealed class GenericTypeKey : ParameterizedTypeKey +sealed class GenericTypeKey(string name, ImmutableList parameters) : + ParameterizedTypeKey(name, parameters) { - public GenericTypeKey(string name, ImmutableList parameters) : - base(name, parameters) { } - public override string ToString() => Name + "<" + string.Join(", ", Parameters) + ">"; } -sealed class NullableTypeKey : ParameterizedTypeKey +sealed class NullableTypeKey(TypeKey underlying) : + ParameterizedTypeKey("?", underlying) { - public NullableTypeKey(TypeKey underlying) : base("?", underlying) { } public override string ToString() => Parameters.Single() + "?"; } -sealed class TupleTypeKey : ParameterizedTypeKey +sealed class TupleTypeKey(ImmutableList parameters) : + ParameterizedTypeKey("()", parameters) { - public TupleTypeKey(ImmutableList parameters) : - base("()", parameters) { } - public override string ToString() => "(" + string.Join(", ", Parameters) + ")"; } -sealed class ArrayTypeKey : ParameterizedTypeKey +sealed class ArrayTypeKey(TypeKey element, IEnumerable ranks) : + ParameterizedTypeKey("[]", element) { - public ArrayTypeKey(TypeKey element, IEnumerable ranks) : - base("[]", element) => Ranks = ImmutableList.CreateRange(ranks); - - public ImmutableList Ranks { get; } + public ImmutableList Ranks { get; } = ImmutableList.CreateRange(ranks); public override string ToString() => Parameters.Single() + string.Concat(from r in Ranks From a0f72ab0d1eacb752e2d940ecac436ea382c7af6 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 18 Nov 2023 16:04:22 +0100 Subject: [PATCH 126/157] Address "Subsets" to-do about clearer members names --- MoreLinq/Subsets.cs | 43 +++++++++++++++++++++---------------------- 1 file changed, 21 insertions(+), 22 deletions(-) diff --git a/MoreLinq/Subsets.cs b/MoreLinq/Subsets.cs index 7852dd3c2..41c75eb6c 100644 --- a/MoreLinq/Subsets.cs +++ b/MoreLinq/Subsets.cs @@ -136,14 +136,12 @@ sealed class SubsetEnumerator : IEnumerator> readonly T[] _subset; // the current subset to return readonly int[] _indices; // indices into the original set - // TODO: It would be desirable to give these index members clearer names bool _continue; // termination indicator, set when all subsets have been produced - int _m; // previous swap index (upper index) - int _m2; // current swap index (lower index) - int _k; // size of the subset being produced - int _n; // size of the original set (sequence) - int _z; // count of items excluded from the subset + int _prevSwapIndex; // previous swap index (upper index) + int _currSwapIndex; // current swap index (lower index) + int _subsetSize; // size of the subset being produced + int _setSize; // size of the original set (sequence) public SubsetEnumerator(IList set, int subsetSize) { @@ -161,11 +159,10 @@ public SubsetEnumerator(IList set, int subsetSize) public void Reset() { - _m = _subset.Length; - _m2 = -1; - _k = _subset.Length; - _n = _set.Count; - _z = _n - _k + 1; + _prevSwapIndex = _subset.Length; + _currSwapIndex = -1; + _subsetSize = _subset.Length; + _setSize = _set.Count; _continue = true; } @@ -178,27 +175,29 @@ public bool MoveNext() if (!_continue) return false; - if (_m2 == -1) + if (_currSwapIndex == -1) { - _m2 = 0; - _m = _k; + _currSwapIndex = 0; + _prevSwapIndex = _subsetSize; } else { - if (_m2 < _n - _m) + if (_currSwapIndex < _setSize - _prevSwapIndex) { - _m = 0; + _prevSwapIndex = 0; } - _m++; - _m2 = _indices[_k - _m]; + _prevSwapIndex++; + _currSwapIndex = _indices[_subsetSize - _prevSwapIndex]; } - for (var j = 1; j <= _m; j++) - _indices[_k + j - _m - 1] = _m2 + j; + for (var j = 1; j <= _prevSwapIndex; j++) + _indices[_subsetSize + j - _prevSwapIndex - 1] = _currSwapIndex + j; ExtractSubset(); - _continue = _indices.Length > 0 && _indices[0] != _z; + // ........................................ count of items excluded from the subset + _continue = _indices is [var i, ..] && i != _setSize - _subsetSize + 1; + return true; } @@ -206,7 +205,7 @@ void IDisposable.Dispose() { } void ExtractSubset() { - for (var i = 0; i < _k; i++) + for (var i = 0; i < _subsetSize; i++) _subset[i] = _set[_indices[i] - 1]; } } From 3de8b3fc9fa7fc74cb093df469ab948e544f04bf Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Sun, 19 Nov 2023 07:13:53 -0600 Subject: [PATCH 127/157] Refactor "RandomSubset" internals for DRY, removing closure This is a squashed merge of PR #1049. --------- Co-authored-by: Atif Aziz --- MoreLinq/RandomSubset.cs | 11 +++++------ MoreLinq/Shuffle.cs | 7 +------ 2 files changed, 6 insertions(+), 12 deletions(-) diff --git a/MoreLinq/RandomSubset.cs b/MoreLinq/RandomSubset.cs index f5f0de015..3bb1decc8 100644 --- a/MoreLinq/RandomSubset.cs +++ b/MoreLinq/RandomSubset.cs @@ -61,10 +61,10 @@ public static IEnumerable RandomSubset(this IEnumerable source, int sub if (source == null) throw new ArgumentNullException(nameof(source)); if (subsetSize < 0) throw new ArgumentOutOfRangeException(nameof(subsetSize)); - return RandomSubsetImpl(source, rand, seq => (seq.ToArray(), subsetSize)); + return RandomSubsetImpl(source, rand, subsetSize); } - static IEnumerable RandomSubsetImpl(IEnumerable source, Random rand, Func, (T[], int)> seeder) + static IEnumerable RandomSubsetImpl(IEnumerable source, Random rand, int? subsetSize) { // The simplest and most efficient way to return a random subset is to perform // an in-place, partial Fisher-Yates shuffle of the sequence. While we could do @@ -72,15 +72,14 @@ static IEnumerable RandomSubsetImpl(IEnumerable source, Random rand, Fu // than the length of the sequence. // See: http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle - var (array, subsetSize) = seeder(source); + var array = source.ToArray(); + subsetSize ??= array.Length; if (array.Length < subsetSize) { -#pragma warning disable CA2208 // Instantiate argument exceptions correctly - // TODO Throw InvalidOperationException instead? + // TODO Throw InvalidOperationException instead? throw new ArgumentOutOfRangeException(nameof(subsetSize), "Subset size must be less than or equal to the source length."); -#pragma warning restore CA2208 // Instantiate argument exceptions correctly } var m = 0; // keeps track of count items shuffled diff --git a/MoreLinq/Shuffle.cs b/MoreLinq/Shuffle.cs index c7cac7d6e..dad62d3bf 100644 --- a/MoreLinq/Shuffle.cs +++ b/MoreLinq/Shuffle.cs @@ -19,7 +19,6 @@ namespace MoreLinq { using System; using System.Collections.Generic; - using System.Linq; public static partial class MoreEnumerable { @@ -70,11 +69,7 @@ public static IEnumerable Shuffle(this IEnumerable source, Random rand) if (source == null) throw new ArgumentNullException(nameof(source)); if (rand == null) throw new ArgumentNullException(nameof(rand)); - return RandomSubsetImpl(source, rand, seq => - { - var array = seq.ToArray(); - return (array, array.Length); - }); + return RandomSubsetImpl(source, rand, subsetSize: null); } } } From 2024e821c44dae4383e664946fcb8dc0344dae0e Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 18 Nov 2023 15:16:20 +0100 Subject: [PATCH 128/157] Set naming rules & "this" qualifier as a by-product --- .editorconfig | 36 ++++++++++ MoreLinq.Test/Async/MergeTest.cs | 14 ++-- MoreLinq.Test/Async/TestingAsyncSequence.cs | 32 ++++----- MoreLinq.Test/Async/WatchableEnumerator.cs | 8 +-- MoreLinq.Test/BatchTest.cs | 24 +++---- MoreLinq.Test/BreakingCollection.cs | 4 +- MoreLinq.Test/BreakingReadOnlyCollection.cs | 4 +- MoreLinq.Test/BreakingReadOnlyList.cs | 4 +- MoreLinq.Test/CountDownTest.cs | 24 +++---- MoreLinq.Test/EqualityComparer.cs | 12 ++-- MoreLinq.Test/ReadOnlyCollection.cs | 6 +- MoreLinq.Test/Scope.cs | 6 +- MoreLinq.Test/SequenceReader.cs | 8 +-- MoreLinq.Test/TestingSequence.cs | 36 +++++----- MoreLinq.Test/ToDataTableTest.cs | 30 ++++----- MoreLinq.Test/TrySingleTest.cs | 6 +- MoreLinq.Test/WatchableEnumerator.cs | 10 +-- MoreLinq/CollectionLike.cs | 16 ++--- MoreLinq/Collections/Dictionary.cs | 10 +-- MoreLinq/Delegating.cs | 10 +-- MoreLinq/Experimental/Await.cs | 10 +-- MoreLinq/Experimental/Batch.cs | 46 ++++++------- MoreLinq/Experimental/Memoize.cs | 68 +++++++++---------- MoreLinq/GlobalRandom.cs | 6 +- MoreLinq/ListLike.cs | 18 ++--- MoreLinq/Lookup.cs | 2 + MoreLinq/Maxima.cs | 6 +- MoreLinq/Permutations.cs | 70 ++++++++++---------- MoreLinq/Reactive/Subject.cs | 34 +++++----- MoreLinq/Return.cs | 10 +-- MoreLinq/ReverseComparer.cs | 4 +- MoreLinq/Subsets.cs | 73 +++++++++++---------- 32 files changed, 343 insertions(+), 304 deletions(-) diff --git a/.editorconfig b/.editorconfig index bf62f14a8..095f2d9b8 100644 --- a/.editorconfig +++ b/.editorconfig @@ -31,6 +31,42 @@ dotnet_analyzer_diagnostic.category-Style.severity = warning # IDE0022: Use expression/block body for methods dotnet_diagnostic.IDE0022.severity = suggestion +# IDE1006: Naming rule violation +dotnet_diagnostic.IDE1006.severity = warning + +# Naming capitalization styles +dotnet_naming_style.camel_case_style.capitalization = camel_case +dotnet_naming_style.pascal_case_style.capitalization = pascal_case + +# Naming rule that private instance fields must use camel case +dotnet_naming_symbols.private_fields.applicable_kinds = field +dotnet_naming_symbols.private_fields.applicable_accessibilities = private +dotnet_naming_rule.camel_case_private_fields.severity = warning +dotnet_naming_rule.camel_case_private_fields.symbols = private_fields +dotnet_naming_rule.camel_case_private_fields.style = camel_case_style + +# Naming rule that static read-only fields must use Pascal case +dotnet_naming_symbols.static_readonly_fields.applicable_kinds = field +dotnet_naming_symbols.static_readonly_fields.applicable_accessibilities = * +dotnet_naming_symbols.static_readonly_fields.required_modifiers = readonly, static +dotnet_naming_rule.pascal_case_static_readonly_fields.severity = warning +dotnet_naming_rule.pascal_case_static_readonly_fields.symbols = static_readonly_fields +dotnet_naming_rule.pascal_case_static_readonly_fields.style = pascal_case_style + +# Naming rule that const fields must use Pascal case +dotnet_naming_symbols.const_fields.applicable_kinds = field +dotnet_naming_symbols.const_fields.applicable_accessibilities = * +dotnet_naming_symbols.const_fields.required_modifiers = const +dotnet_naming_rule.pascal_case_const_fields.severity = warning +dotnet_naming_rule.pascal_case_const_fields.symbols = const_fields +dotnet_naming_rule.pascal_case_const_fields.style = pascal_case_style + +# this. preferences +dotnet_style_qualification_for_event = false +dotnet_style_qualification_for_field = true +dotnet_style_qualification_for_method = false +dotnet_style_qualification_for_property = false + # Prefer "var" everywhere csharp_style_var_for_built_in_types = true csharp_style_var_when_type_is_apparent = true diff --git a/MoreLinq.Test/Async/MergeTest.cs b/MoreLinq.Test/Async/MergeTest.cs index 81bbc18b8..874ddf998 100644 --- a/MoreLinq.Test/Async/MergeTest.cs +++ b/MoreLinq.Test/Async/MergeTest.cs @@ -86,22 +86,22 @@ sealed class AsyncControl { sealed record State(TaskCompletionSource TaskCompletionSource, T Result); - State? _state; + State? state; public Task Result(T result) { - if (_state is not null) + if (this.state is not null) throw new InvalidOperationException(); - _state = new State(new TaskCompletionSource(), result); - return _state.TaskCompletionSource.Task; + this.state = new State(new TaskCompletionSource(), result); + return this.state.TaskCompletionSource.Task; } public void Complete() { - if (_state is not { } state) + if (this.state is not { } someState) throw new InvalidOperationException(); - _state = null; - state.TaskCompletionSource.SetResult(state.Result); + this.state = null; + someState.TaskCompletionSource.SetResult(someState.Result); } } diff --git a/MoreLinq.Test/Async/TestingAsyncSequence.cs b/MoreLinq.Test/Async/TestingAsyncSequence.cs index e63f2227e..af234111c 100644 --- a/MoreLinq.Test/Async/TestingAsyncSequence.cs +++ b/MoreLinq.Test/Async/TestingAsyncSequence.cs @@ -43,14 +43,14 @@ source is not null sealed class TestingAsyncSequence : IAsyncEnumerable, IDisposable { - bool? _disposed; - IAsyncEnumerable? _source; - ExceptionDispatchInfo? _disposeErrorInfo; + bool? disposed; + IAsyncEnumerable? source; + ExceptionDispatchInfo? disposeErrorInfo; internal TestingAsyncSequence(IAsyncEnumerable sequence) => - _source = sequence; + this.source = sequence; - public bool IsDisposed => _disposed == true; + public bool IsDisposed => this.disposed == true; public int MoveNextCallCount { get; private set; } void IDisposable.Dispose() => @@ -62,24 +62,24 @@ void IDisposable.Dispose() => void AssertDisposed() { - _disposeErrorInfo?.Throw(); + this.disposeErrorInfo?.Throw(); - if (_disposed is null) + if (this.disposed is null) return; - Assert.IsTrue(_disposed, "Expected sequence to be disposed."); - _disposed = null; + Assert.IsTrue(this.disposed, "Expected sequence to be disposed."); + this.disposed = null; } public IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { - Assert.That(_source, Is.Not.Null, + Assert.That(this.source, Is.Not.Null, "LINQ operators should not enumerate a sequence more than once."); // Dammit (!) below is okay since we assert above it's not null. - var enumerator = _source!.GetAsyncEnumerator(cancellationToken).AsWatchable(); + var enumerator = this.source!.GetAsyncEnumerator(cancellationToken).AsWatchable(); - _disposed = false; + this.disposed = false; enumerator.Disposed += delegate { // If the following assertion fails the capture the error @@ -90,14 +90,14 @@ public IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToke try { - Assert.That(_disposed, Is.False, "LINQ operators should not dispose a sequence more than once."); + Assert.That(this.disposed, Is.False, "LINQ operators should not dispose a sequence more than once."); } catch (AssertionException e) { - _disposeErrorInfo = ExceptionDispatchInfo.Capture(e); + this.disposeErrorInfo = ExceptionDispatchInfo.Capture(e); } - _disposed = true; + this.disposed = true; }; var ended = false; @@ -108,7 +108,7 @@ public IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToke MoveNextCallCount++; }; - _source = null; + this.source = null; return enumerator; } } diff --git a/MoreLinq.Test/Async/WatchableEnumerator.cs b/MoreLinq.Test/Async/WatchableEnumerator.cs index e4635533f..969b7685d 100644 --- a/MoreLinq.Test/Async/WatchableEnumerator.cs +++ b/MoreLinq.Test/Async/WatchableEnumerator.cs @@ -29,23 +29,23 @@ partial class TestExtensions sealed class WatchableEnumerator(IAsyncEnumerator source) : IAsyncEnumerator { - readonly IAsyncEnumerator _source = source ?? throw new ArgumentNullException(nameof(source)); + readonly IAsyncEnumerator source = source ?? throw new ArgumentNullException(nameof(source)); public event EventHandler? Disposed; public event EventHandler? MoveNextCalled; - public T Current => _source.Current; + public T Current => this.source.Current; public async ValueTask MoveNextAsync() { - var moved = await _source.MoveNextAsync(); + var moved = await this.source.MoveNextAsync(); MoveNextCalled?.Invoke(this, moved); return moved; } public async ValueTask DisposeAsync() { - await _source.DisposeAsync(); + await this.source.DisposeAsync(); Disposed?.Invoke(this, EventArgs.Empty); } } diff --git a/MoreLinq.Test/BatchTest.cs b/MoreLinq.Test/BatchTest.cs index f755bc114..abf306d0f 100644 --- a/MoreLinq.Test/BatchTest.cs +++ b/MoreLinq.Test/BatchTest.cs @@ -375,34 +375,34 @@ public void BatchBucketSelectorCurrentList() sealed class TestArrayPool : ArrayPool, IDisposable { - T[]? _pooledArray; - T[]? _rentedArray; + T[]? pooledArray; + T[]? rentedArray; public override T[] Rent(int minimumLength) { - if (_pooledArray is null && _rentedArray is null) - _pooledArray = new T[minimumLength * 2]; + if (this.pooledArray is null && this.rentedArray is null) + this.pooledArray = new T[minimumLength * 2]; - (_pooledArray, _rentedArray) = - (null, _pooledArray ?? throw new InvalidOperationException("The pool is exhausted.")); + (this.pooledArray, this.rentedArray) = + (null, this.pooledArray ?? throw new InvalidOperationException("The pool is exhausted.")); - return _rentedArray; + return this.rentedArray; } public override void Return(T[] array, bool clearArray = false) { - if (_rentedArray is null) + if (this.rentedArray is null) throw new InvalidOperationException("Cannot return when nothing has been rented from this pool."); - if (array != _rentedArray) + if (array != this.rentedArray) throw new InvalidOperationException("Cannot return what has not been rented from this pool."); - _pooledArray = array; - _rentedArray = null; + this.pooledArray = array; + this.rentedArray = null; } public void Dispose() => - Assert.That(_rentedArray, Is.Null); + Assert.That(this.rentedArray, Is.Null); } } } diff --git a/MoreLinq.Test/BreakingCollection.cs b/MoreLinq.Test/BreakingCollection.cs index 8dda669cb..20489b0d2 100644 --- a/MoreLinq.Test/BreakingCollection.cs +++ b/MoreLinq.Test/BreakingCollection.cs @@ -23,10 +23,10 @@ namespace MoreLinq.Test class BreakingCollection(IList list) : BreakingSequence, ICollection { - protected readonly IList List = list; - public BreakingCollection(params T[] values) : this((IList)values) { } + protected IList List { get; } = list; + public int Count => List.Count; public void Add(T item) => throw new NotImplementedException(); diff --git a/MoreLinq.Test/BreakingReadOnlyCollection.cs b/MoreLinq.Test/BreakingReadOnlyCollection.cs index 927a9f608..002c471cc 100644 --- a/MoreLinq.Test/BreakingReadOnlyCollection.cs +++ b/MoreLinq.Test/BreakingReadOnlyCollection.cs @@ -22,10 +22,10 @@ namespace MoreLinq.Test class BreakingReadOnlyCollection(IReadOnlyCollection collection) : BreakingSequence, IReadOnlyCollection { - readonly IReadOnlyCollection _collection = collection; + readonly IReadOnlyCollection collection = collection; public BreakingReadOnlyCollection(params T[] values) : this((IReadOnlyCollection)values) { } - public int Count => _collection.Count; + public int Count => this.collection.Count; } } diff --git a/MoreLinq.Test/BreakingReadOnlyList.cs b/MoreLinq.Test/BreakingReadOnlyList.cs index 45c84963c..9aa954217 100644 --- a/MoreLinq.Test/BreakingReadOnlyList.cs +++ b/MoreLinq.Test/BreakingReadOnlyList.cs @@ -31,10 +31,10 @@ sealed class BreakingReadOnlyList(IReadOnlyList list) : BreakingReadOnlyCollection(list), IReadOnlyList { - readonly IReadOnlyList _list = list; + readonly IReadOnlyList list = list; public BreakingReadOnlyList(params T[] values) : this((IReadOnlyList)values) { } - public T this[int index] => _list[index]; + public T this[int index] => this.list[index]; } } diff --git a/MoreLinq.Test/CountDownTest.cs b/MoreLinq.Test/CountDownTest.cs index 1be4c6846..e852a3e0c 100644 --- a/MoreLinq.Test/CountDownTest.cs +++ b/MoreLinq.Test/CountDownTest.cs @@ -152,13 +152,13 @@ public static IReadOnlyCollection abstract class Sequence : IEnumerable { - readonly Func, IEnumerator> _em; + readonly Func, IEnumerator> em; protected Sequence(Func, IEnumerator>? em) => - _em = em ?? (e => e); + this.em = em ?? (e => e); public IEnumerator GetEnumerator() => - _em(Items.GetEnumerator()); + this.em(Items.GetEnumerator()); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); @@ -174,15 +174,15 @@ sealed class Collection(ICollection collection, Func, IEnumerator>? em = null) : Sequence(em), ICollection { - readonly ICollection _collection = collection ?? throw new ArgumentNullException(nameof(collection)); + readonly ICollection collection = collection ?? throw new ArgumentNullException(nameof(collection)); - public int Count => _collection.Count; - public bool IsReadOnly => _collection.IsReadOnly; + public int Count => this.collection.Count; + public bool IsReadOnly => this.collection.IsReadOnly; - protected override IEnumerable Items => _collection; + protected override IEnumerable Items => this.collection; - public bool Contains(T item) => _collection.Contains(item); - public void CopyTo(T[] array, int arrayIndex) => _collection.CopyTo(array, arrayIndex); + public bool Contains(T item) => this.collection.Contains(item); + public void CopyTo(T[] array, int arrayIndex) => this.collection.CopyTo(array, arrayIndex); public void Add(T item) => throw new NotImplementedException(); public void Clear() => throw new NotImplementedException(); @@ -198,11 +198,11 @@ sealed class ReadOnlyCollection(ICollection collection, Func, IEnumerator>? em = null) : Sequence(em), IReadOnlyCollection { - readonly ICollection _collection = collection ?? throw new ArgumentNullException(nameof(collection)); + readonly ICollection collection = collection ?? throw new ArgumentNullException(nameof(collection)); - public int Count => _collection.Count; + public int Count => this.collection.Count; - protected override IEnumerable Items => _collection; + protected override IEnumerable Items => this.collection; } } diff --git a/MoreLinq.Test/EqualityComparer.cs b/MoreLinq.Test/EqualityComparer.cs index 4e3a4e8a9..59245b170 100644 --- a/MoreLinq.Test/EqualityComparer.cs +++ b/MoreLinq.Test/EqualityComparer.cs @@ -32,20 +32,20 @@ public static IEqualityComparer Create(Func comparer) => sealed class DelegatingComparer : IEqualityComparer { - readonly Func _comparer; - readonly Func _hasher; + readonly Func comparer; + readonly Func hasher; public DelegatingComparer(Func comparer) : this(comparer, x => x == null ? 0 : x.GetHashCode()) { } DelegatingComparer(Func comparer, Func hasher) { - _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer)); - _hasher = hasher ?? throw new ArgumentNullException(nameof(hasher)); + this.comparer = comparer ?? throw new ArgumentNullException(nameof(comparer)); + this.hasher = hasher ?? throw new ArgumentNullException(nameof(hasher)); } - public bool Equals(T? x, T? y) => _comparer(x, y); - public int GetHashCode(T obj) => _hasher(obj); + public bool Equals(T? x, T? y) => this.comparer(x, y); + public int GetHashCode(T obj) => this.hasher(obj); } } } diff --git a/MoreLinq.Test/ReadOnlyCollection.cs b/MoreLinq.Test/ReadOnlyCollection.cs index 82004faf4..099dacc1c 100644 --- a/MoreLinq.Test/ReadOnlyCollection.cs +++ b/MoreLinq.Test/ReadOnlyCollection.cs @@ -29,12 +29,12 @@ sealed class ListCollection(TList list) : IReadOnlyCollection where TList : IList { - readonly TList _list = list; + readonly TList list = list; - public IEnumerator GetEnumerator() => _list.GetEnumerator(); + public IEnumerator GetEnumerator() => this.list.GetEnumerator(); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); - public int Count => _list.Count; + public int Count => this.list.Count; } } } diff --git a/MoreLinq.Test/Scope.cs b/MoreLinq.Test/Scope.cs index 8a7889113..b770bc14f 100644 --- a/MoreLinq.Test/Scope.cs +++ b/MoreLinq.Test/Scope.cs @@ -21,10 +21,10 @@ namespace MoreLinq.Test abstract class Scope : IDisposable { - readonly T _old; + readonly T old; - protected Scope(T current) => _old = current; - public virtual void Dispose() => Restore(_old); + protected Scope(T current) => this.old = current; + public virtual void Dispose() => Restore(this.old); protected abstract void Restore(T old); } } diff --git a/MoreLinq.Test/SequenceReader.cs b/MoreLinq.Test/SequenceReader.cs index c49c51c3b..c65dec7a3 100644 --- a/MoreLinq.Test/SequenceReader.cs +++ b/MoreLinq.Test/SequenceReader.cs @@ -42,7 +42,7 @@ public static SequenceReader Read(this IEnumerable source) /// Source enumerator. sealed class SequenceReader(IEnumerator enumerator) : IDisposable { - IEnumerator? _enumerator = enumerator ?? throw new ArgumentNullException(nameof(enumerator)); + IEnumerator? enumerator = enumerator ?? throw new ArgumentNullException(nameof(enumerator)); /// /// Initializes a instance @@ -60,7 +60,7 @@ static IEnumerator GetEnumerator(IEnumerable source) } IEnumerator Enumerator => - _enumerator ?? throw new ObjectDisposedException(GetType().FullName); + this.enumerator ?? throw new ObjectDisposedException(GetType().FullName); /// /// Reads a value otherwise throws @@ -100,9 +100,9 @@ public void ReadEnd() public void Dispose() { - var e = _enumerator; + var e = this.enumerator; if (e == null) return; - _enumerator = null; + this.enumerator = null; e.Dispose(); } } diff --git a/MoreLinq.Test/TestingSequence.cs b/MoreLinq.Test/TestingSequence.cs index 479459a9b..756c8b58c 100644 --- a/MoreLinq.Test/TestingSequence.cs +++ b/MoreLinq.Test/TestingSequence.cs @@ -64,45 +64,45 @@ public enum Options /// sealed class TestingSequence : IEnumerable, IDisposable { - readonly IEnumerable _sequence; - readonly Options _options; - readonly int _maxEnumerations; + readonly IEnumerable sequence; + readonly Options options; + readonly int maxEnumerations; - int _disposedCount; - int _enumerationCount; + int disposedCount; + int enumerationCount; internal TestingSequence(IEnumerable sequence, Options options, int maxEnumerations) { - _sequence = sequence; - _maxEnumerations = maxEnumerations; - _options = options; + this.sequence = sequence; + this.maxEnumerations = maxEnumerations; + this.options = options; } public int MoveNextCallCount { get; private set; } - public bool IsDisposed => _enumerationCount > 0 && _disposedCount == _enumerationCount; + public bool IsDisposed => this.enumerationCount > 0 && this.disposedCount == this.enumerationCount; void IDisposable.Dispose() { - if (_enumerationCount > 0) - Assert.That(_disposedCount, Is.EqualTo(_enumerationCount), ExpectedDisposal); + if (this.enumerationCount > 0) + Assert.That(this.disposedCount, Is.EqualTo(this.enumerationCount), ExpectedDisposal); } public IEnumerator GetEnumerator() { - Assert.That(_enumerationCount, Is.LessThan(_maxEnumerations), TooManyEnumerations); - Assert.That(_enumerationCount, Is.EqualTo(_disposedCount), SimultaneousEnumerations); - _enumerationCount++; + Assert.That(this.enumerationCount, Is.LessThan(this.maxEnumerations), TooManyEnumerations); + Assert.That(this.enumerationCount, Is.EqualTo(this.disposedCount), SimultaneousEnumerations); + this.enumerationCount++; - var enumerator = _sequence.GetEnumerator().AsWatchable(); + var enumerator = this.sequence.GetEnumerator().AsWatchable(); var disposed = false; enumerator.Disposed += delegate { if (!disposed) { - _disposedCount++; + this.disposedCount++; disposed = true; } - else if (!_options.HasFlag(Options.AllowRepeatedDisposals)) + else if (!this.options.HasFlag(Options.AllowRepeatedDisposals)) { Assert.Fail(TooManyDisposals); } @@ -112,7 +112,7 @@ public IEnumerator GetEnumerator() enumerator.MoveNextCalled += (_, moved) => { Assert.That(disposed, Is.False, MoveNextPostDisposal); - if (!_options.HasFlag(Options.AllowRepeatedMoveNexts)) + if (!this.options.HasFlag(Options.AllowRepeatedMoveNexts)) Assert.That(ended, Is.False, MoveNextPostEnumeration); ended = !moved; diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs index 5842fe23a..9b4249d62 100644 --- a/MoreLinq.Test/ToDataTableTest.cs +++ b/MoreLinq.Test/ToDataTableTest.cs @@ -42,20 +42,20 @@ sealed class TestObject(int key) } - readonly IReadOnlyCollection _testObjects; + readonly IReadOnlyCollection testObjects; public ToDataTableTest() => - _testObjects = Enumerable.Range(0, 3) - .Select(i => new TestObject(i)) - .ToArray(); + this.testObjects = Enumerable.Range(0, 3) + .Select(i => new TestObject(i)) + .ToArray(); [Test] public void ToDataTableNullMemberExpressionMethod() { Expression>? expression = null; - Assert.That(() => _testObjects.ToDataTable(expression!), + Assert.That(() => this.testObjects.ToDataTable(expression!), Throws.ArgumentException("expressions")); } @@ -65,7 +65,7 @@ public void ToDataTableTableWithWrongColumnNames() using var dt = new DataTable(); _ = dt.Columns.Add("Test"); - Assert.That(() => _testObjects.ToDataTable(dt), + Assert.That(() => this.testObjects.ToDataTable(dt), Throws.ArgumentException("table")); } @@ -75,14 +75,14 @@ public void ToDataTableTableWithWrongColumnDataType() using var dt = new DataTable(); _ = dt.Columns.Add("AString", typeof(int)); - Assert.That(() => _testObjects.ToDataTable(dt, t => t.AString), + Assert.That(() => this.testObjects.ToDataTable(dt, t => t.AString), Throws.ArgumentException("table")); } [Test] public void ToDataTableMemberExpressionMethod() { - Assert.That(() => _testObjects.ToDataTable(t => t.ToString()), + Assert.That(() => this.testObjects.ToDataTable(t => t.ToString()), Throws.ArgumentException("lambda")); } @@ -90,28 +90,28 @@ public void ToDataTableMemberExpressionMethod() [Test] public void ToDataTableMemberExpressionNonMember() { - Assert.That(() => _testObjects.ToDataTable(t => t.ToString().Length), + Assert.That(() => this.testObjects.ToDataTable(t => t.ToString().Length), Throws.ArgumentException("lambda")); } [Test] public void ToDataTableMemberExpressionIndexer() { - Assert.That(() => _testObjects.ToDataTable(t => t[0]), + Assert.That(() => this.testObjects.ToDataTable(t => t[0]), Throws.ArgumentException("lambda")); } [Test] public void ToDataTableMemberExpressionStatic() { - Assert.That(() => _ = _testObjects.ToDataTable(_ => DateTime.Now), + Assert.That(() => _ = this.testObjects.ToDataTable(_ => DateTime.Now), Throws.ArgumentException("lambda")); } [Test] public void ToDataTableSchemaInDeclarationOrder() { - var dt = _testObjects.ToDataTable(); + var dt = this.testObjects.ToDataTable(); // Assert properties first, then fields, then in declaration order @@ -134,14 +134,14 @@ public void ToDataTableSchemaInDeclarationOrder() [Test] public void ToDataTableContainsAllElements() { - var dt = _testObjects.ToDataTable(); - Assert.That(dt.Rows.Count, Is.EqualTo(_testObjects.Count)); + var dt = this.testObjects.ToDataTable(); + Assert.That(dt.Rows.Count, Is.EqualTo(this.testObjects.Count)); } [Test] public void ToDataTableWithExpression() { - var dt = _testObjects.ToDataTable(t => t.AString); + var dt = this.testObjects.ToDataTable(t => t.AString); Assert.That(dt.Columns[0].Caption, Is.EqualTo("AString")); Assert.That(dt.Columns[0].DataType, Is.EqualTo(typeof(string))); diff --git a/MoreLinq.Test/TrySingleTest.cs b/MoreLinq.Test/TrySingleTest.cs index 01b12b313..e96a21fce 100644 --- a/MoreLinq.Test/TrySingleTest.cs +++ b/MoreLinq.Test/TrySingleTest.cs @@ -72,9 +72,9 @@ public void TrySingleWithSingletonCollection(IEnumerable source, T result) class BreakingSingleElementCollectionBase : IEnumerable { - readonly T _element; + readonly T element; - protected BreakingSingleElementCollectionBase(T element) => _element = element; + protected BreakingSingleElementCollectionBase(T element) => this.element = element; #pragma warning disable CA1822 // Mark members as static public int Count => 1; @@ -82,7 +82,7 @@ class BreakingSingleElementCollectionBase : IEnumerable public IEnumerator GetEnumerator() { - yield return _element; + yield return this.element; Assert.Fail($"{nameof(ExperimentalEnumerable.TrySingle)} should not have attempted to consume a second element."); } diff --git a/MoreLinq.Test/WatchableEnumerator.cs b/MoreLinq.Test/WatchableEnumerator.cs index 2d782604d..8428dfcab 100644 --- a/MoreLinq.Test/WatchableEnumerator.cs +++ b/MoreLinq.Test/WatchableEnumerator.cs @@ -29,7 +29,7 @@ partial class TestExtensions sealed class WatchableEnumerator(IEnumerator source) : IEnumerator { - readonly IEnumerator _source = source ?? throw new ArgumentNullException(nameof(source)); + readonly IEnumerator source = source ?? throw new ArgumentNullException(nameof(source)); public event EventHandler? Disposed; public event EventHandler? GetCurrentCalled; @@ -40,24 +40,24 @@ public T Current get { GetCurrentCalled?.Invoke(this, EventArgs.Empty); - return _source.Current; + return this.source.Current; } } object? IEnumerator.Current => this.Current; - public void Reset() => _source.Reset(); + public void Reset() => this.source.Reset(); public bool MoveNext() { - var moved = _source.MoveNext(); + var moved = this.source.MoveNext(); MoveNextCalled?.Invoke(this, moved); return moved; } public void Dispose() { - _source.Dispose(); + this.source.Dispose(); Disposed?.Invoke(this, EventArgs.Empty); } } diff --git a/MoreLinq/CollectionLike.cs b/MoreLinq/CollectionLike.cs index 42c642976..bc15c1029 100644 --- a/MoreLinq/CollectionLike.cs +++ b/MoreLinq/CollectionLike.cs @@ -29,25 +29,25 @@ namespace MoreLinq readonly struct CollectionLike { - readonly ICollection? _rw; - readonly IReadOnlyCollection? _ro; + readonly ICollection? rw; + readonly IReadOnlyCollection? ro; public CollectionLike(ICollection collection) { - _rw = collection ?? throw new ArgumentNullException(nameof(collection)); - _ro = null; + this.rw = collection ?? throw new ArgumentNullException(nameof(collection)); + this.ro = null; } public CollectionLike(IReadOnlyCollection collection) { - _rw = null; - _ro = collection ?? throw new ArgumentNullException(nameof(collection)); + this.rw = null; + this.ro = collection ?? throw new ArgumentNullException(nameof(collection)); } - public int Count => _rw?.Count ?? _ro?.Count ?? 0; + public int Count => this.rw?.Count ?? this.ro?.Count ?? 0; public IEnumerator GetEnumerator() => - _rw?.GetEnumerator() ?? _ro?.GetEnumerator() ?? Enumerable.Empty().GetEnumerator(); + this.rw?.GetEnumerator() ?? this.ro?.GetEnumerator() ?? Enumerable.Empty().GetEnumerator(); } static class CollectionLike diff --git a/MoreLinq/Collections/Dictionary.cs b/MoreLinq/Collections/Dictionary.cs index f79b23104..894e289e6 100644 --- a/MoreLinq/Collections/Dictionary.cs +++ b/MoreLinq/Collections/Dictionary.cs @@ -30,24 +30,24 @@ namespace MoreLinq.Collections sealed class Dictionary { - readonly System.Collections.Generic.Dictionary, TValue> _dict; + readonly System.Collections.Generic.Dictionary, TValue> dict; public Dictionary(IEqualityComparer comparer) { var keyComparer = ReferenceEquals(comparer, EqualityComparer.Default) ? null : new ValueTupleItemComparer(comparer); - _dict = new System.Collections.Generic.Dictionary, TValue>(keyComparer); + this.dict = new System.Collections.Generic.Dictionary, TValue>(keyComparer); } public TValue this[TKey key] { - get => _dict[ValueTuple.Create(key)]; - set => _dict[ValueTuple.Create(key)] = value; + get => this.dict[ValueTuple.Create(key)]; + set => this.dict[ValueTuple.Create(key)] = value; } public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value) => - _dict.TryGetValue(ValueTuple.Create(key), out value); + this.dict.TryGetValue(ValueTuple.Create(key), out value); sealed class ValueTupleItemComparer(IEqualityComparer comparer) : IEqualityComparer> diff --git a/MoreLinq/Delegating.cs b/MoreLinq/Delegating.cs index 81c9ada81..80b14938b 100644 --- a/MoreLinq/Delegating.cs +++ b/MoreLinq/Delegating.cs @@ -42,12 +42,12 @@ public static IObserver Observer(Action onNext, sealed class DelegatingDisposable(Action delegatee) : IDisposable { - Action? _delegatee = delegatee ?? throw new ArgumentNullException(nameof(delegatee)); + Action? delegatee = delegatee ?? throw new ArgumentNullException(nameof(delegatee)); public void Dispose() { - var delegatee = _delegatee; - if (delegatee == null || Interlocked.CompareExchange(ref _delegatee, null, delegatee) != delegatee) + var delegatee = this.delegatee; + if (delegatee == null || Interlocked.CompareExchange(ref this.delegatee, null, delegatee) != delegatee) return; delegatee(); } @@ -58,10 +58,10 @@ sealed class DelegatingObserver(Action onNext, Action? onCompleted = null) : IObserver { - readonly Action _onNext = onNext ?? throw new ArgumentNullException(nameof(onNext)); + readonly Action onNext = onNext ?? throw new ArgumentNullException(nameof(onNext)); public void OnCompleted() => onCompleted?.Invoke(); public void OnError(Exception error) => onError?.Invoke(error); - public void OnNext(T value) => _onNext(value); + public void OnNext(T value) => this.onNext(value); } } diff --git a/MoreLinq/Experimental/Await.cs b/MoreLinq/Experimental/Await.cs index c7d1919f6..717a209bc 100644 --- a/MoreLinq/Experimental/Await.cs +++ b/MoreLinq/Experimental/Await.cs @@ -756,27 +756,27 @@ sealed class ConcurrencyGate { public static readonly ConcurrencyGate Unbounded = new(); - readonly SemaphoreSlim? _semaphore; + readonly SemaphoreSlim? semaphore; ConcurrencyGate(SemaphoreSlim? semaphore = null) => - _semaphore = semaphore; + this.semaphore = semaphore; public ConcurrencyGate(int max) : this(new SemaphoreSlim(max, max)) { } public Task EnterAsync(CancellationToken token) { - if (_semaphore == null) + if (this.semaphore == null) { token.ThrowIfCancellationRequested(); return CompletedTask.Instance; } - return _semaphore.WaitAsync(token); + return this.semaphore.WaitAsync(token); } public void Exit() => - _semaphore?.Release(); + this.semaphore?.Release(); } } } diff --git a/MoreLinq/Experimental/Batch.cs b/MoreLinq/Experimental/Batch.cs index f4cae14be..9e9c28425 100644 --- a/MoreLinq/Experimental/Batch.cs +++ b/MoreLinq/Experimental/Batch.cs @@ -228,26 +228,26 @@ ICurrentBufferProvider Cursor(IEnumerator<(T[], int)> source) => sealed class CurrentPoolArrayProvider : CurrentBuffer, ICurrentBufferProvider { - bool _rented; - T[] _array = []; - int _count; - IEnumerator<(T[], int)>? _rental; - ArrayPool? _pool; + bool rented; + T[] array = []; + int count; + IEnumerator<(T[], int)>? rental; + ArrayPool? pool; public CurrentPoolArrayProvider(IEnumerator<(T[], int)> rental, ArrayPool pool) => - (_rental, _pool) = (rental, pool); + (this.rental, this.pool) = (rental, pool); ICurrentBuffer ICurrentBufferProvider.CurrentBuffer => this; public bool UpdateWithNext() { - if (_rental is { Current: var (array, _) } rental) + if (this.rental is { Current: var (array, _) } rental) { - Debug.Assert(_pool is not null); - if (_rented) + Debug.Assert(this.pool is not null); + if (this.rented) { - _pool.Return(array); - _rented = false; + this.pool.Return(array); + this.rented = false; } if (!rental.MoveNext()) @@ -256,34 +256,34 @@ public bool UpdateWithNext() return false; } - _rented = true; - (_array, _count) = rental.Current; + this.rented = true; + (this.array, this.count) = rental.Current; return true; } return false; } - public override int Count => _count; + public override int Count => this.count; public override T this[int index] { - get => index >= 0 && index < Count ? _array[index] : throw new ArgumentOutOfRangeException(nameof(index)); + get => index >= 0 && index < Count ? this.array[index] : throw new ArgumentOutOfRangeException(nameof(index)); set => throw new NotSupportedException(); } public void Dispose() { - if (_rental is { Current: var (array, _) } enumerator) + if (this.rental is { Current: var (array, _) } enumerator) { - Debug.Assert(_pool is not null); - if (_rented) - _pool.Return(array); + Debug.Assert(this.pool is not null); + if (this.rented) + this.pool.Return(array); enumerator.Dispose(); - _array = []; - _count = 0; - _rental = null; - _pool = null; + this.array = []; + this.count = 0; + this.rental = null; + this.pool = null; } } } diff --git a/MoreLinq/Experimental/Memoize.cs b/MoreLinq/Experimental/Memoize.cs index d7ee0f7ab..8e6a3c6b5 100644 --- a/MoreLinq/Experimental/Memoize.cs +++ b/MoreLinq/Experimental/Memoize.cs @@ -64,32 +64,32 @@ public static IEnumerable Memoize(this IEnumerable source) => sealed class MemoizedEnumerable(IEnumerable sequence) : IEnumerable, IDisposable { - List? _cache; - readonly object _locker = new(); - readonly IEnumerable _source = sequence ?? throw new ArgumentNullException(nameof(sequence)); - IEnumerator? _sourceEnumerator; - int? _errorIndex; - ExceptionDispatchInfo? _error; + List? cache; + readonly object locker = new(); + readonly IEnumerable source = sequence ?? throw new ArgumentNullException(nameof(sequence)); + IEnumerator? sourceEnumerator; + int? errorIndex; + ExceptionDispatchInfo? error; public IEnumerator GetEnumerator() { - if (_cache == null) + if (this.cache == null) { - lock (_locker) + lock (this.locker) { - if (_cache == null) + if (this.cache == null) { - _error?.Throw(); + this.error?.Throw(); try { var cache = new List(); // for exception safety, allocate then... - _sourceEnumerator = _source.GetEnumerator(); // (because this can fail) - _cache = cache; // ...commit to state + this.sourceEnumerator = this.source.GetEnumerator(); // (because this can fail) + this.cache = cache; // ...commit to state } catch (Exception ex) { - _error = ExceptionDispatchInfo.Capture(ex); + this.error = ExceptionDispatchInfo.Capture(ex); throw; } } @@ -103,46 +103,46 @@ public IEnumerator GetEnumerator() while (true) { T current; - lock (_locker) + lock (this.locker) { - if (_cache == null) // Cache disposed during iteration? + if (this.cache == null) // Cache disposed during iteration? throw new ObjectDisposedException(nameof(MemoizedEnumerable)); - if (index >= _cache.Count) + if (index >= this.cache.Count) { - if (index == _errorIndex) - Assume.NotNull(_error).Throw(); + if (index == this.errorIndex) + Assume.NotNull(this.error).Throw(); - if (_sourceEnumerator == null) + if (this.sourceEnumerator == null) break; bool moved; try { - moved = _sourceEnumerator.MoveNext(); + moved = this.sourceEnumerator.MoveNext(); } catch (Exception ex) { - _error = ExceptionDispatchInfo.Capture(ex); - _errorIndex = index; - _sourceEnumerator.Dispose(); - _sourceEnumerator = null; + this.error = ExceptionDispatchInfo.Capture(ex); + this.errorIndex = index; + this.sourceEnumerator.Dispose(); + this.sourceEnumerator = null; throw; } if (moved) { - _cache.Add(_sourceEnumerator.Current); + this.cache.Add(this.sourceEnumerator.Current); } else { - _sourceEnumerator.Dispose(); - _sourceEnumerator = null; + this.sourceEnumerator.Dispose(); + this.sourceEnumerator = null; break; } } - current = _cache[index]; + current = this.cache[index]; } yield return current; @@ -155,13 +155,13 @@ public IEnumerator GetEnumerator() public void Dispose() { - lock (_locker) + lock (this.locker) { - _error = null; - _cache = null; - _errorIndex = null; - _sourceEnumerator?.Dispose(); - _sourceEnumerator = null; + this.error = null; + this.cache = null; + this.errorIndex = null; + this.sourceEnumerator?.Dispose(); + this.sourceEnumerator = null; } } } diff --git a/MoreLinq/GlobalRandom.cs b/MoreLinq/GlobalRandom.cs index 900c2c5a2..b83bd1e33 100644 --- a/MoreLinq/GlobalRandom.cs +++ b/MoreLinq/GlobalRandom.cs @@ -48,9 +48,9 @@ sealed partial class GlobalRandom : Random { public static Random Instance { get; } = new GlobalRandom(); - static int _seed = Environment.TickCount; - [ThreadStatic] static Random? _threadRandom; - static Random ThreadRandom => _threadRandom ??= new Random(Interlocked.Increment(ref _seed)); + static int seed = Environment.TickCount; + [ThreadStatic] static Random? threadRandom; + static Random ThreadRandom => threadRandom ??= new Random(Interlocked.Increment(ref seed)); GlobalRandom() { } diff --git a/MoreLinq/ListLike.cs b/MoreLinq/ListLike.cs index 7e774c47f..6015956a9 100644 --- a/MoreLinq/ListLike.cs +++ b/MoreLinq/ListLike.cs @@ -29,25 +29,25 @@ namespace MoreLinq readonly struct ListLike { - readonly IList? _rw; - readonly IReadOnlyList? _ro; + readonly IList? rw; + readonly IReadOnlyList? ro; public ListLike(IList list) { - _rw = list ?? throw new ArgumentNullException(nameof(list)); - _ro = null; + this.rw = list ?? throw new ArgumentNullException(nameof(list)); + this.ro = null; } public ListLike(IReadOnlyList list) { - _rw = null; - _ro = list ?? throw new ArgumentNullException(nameof(list)); + this.rw = null; + this.ro = list ?? throw new ArgumentNullException(nameof(list)); } - public int Count => _rw?.Count ?? _ro?.Count ?? 0; + public int Count => this.rw?.Count ?? this.ro?.Count ?? 0; - public T this[int index] => _rw is { } rw ? rw[index] - : _ro is { } rx ? rx[index] + public T this[int index] => this.rw is { } rw ? rw[index] + : this.ro is { } rx ? rx[index] : throw new ArgumentOutOfRangeException(nameof(index)); } diff --git a/MoreLinq/Lookup.cs b/MoreLinq/Lookup.cs index e9dfd11d9..df2adaaa3 100644 --- a/MoreLinq/Lookup.cs +++ b/MoreLinq/Lookup.cs @@ -27,6 +27,8 @@ #pragma warning disable IDE0040 // Add accessibility modifiers #pragma warning disable IDE0032 // Use auto property #pragma warning disable IDE0017 // Simplify object initialization +#pragma warning disable IDE0009 // Member access should be qualified +#pragma warning disable IDE1006 // Naming rule violation namespace MoreLinq { diff --git a/MoreLinq/Maxima.cs b/MoreLinq/Maxima.cs index d5262251b..5292dbcf8 100644 --- a/MoreLinq/Maxima.cs +++ b/MoreLinq/Maxima.cs @@ -283,8 +283,8 @@ sealed class Extremum : Extrema<(bool, T), T> public static readonly Extrema<(bool, T), T> First = new Extremum(false); public static readonly Extrema<(bool, T), T> Last = new Extremum(true); - readonly bool _poppable; - Extremum(bool poppable) => _poppable = poppable; + readonly bool poppable; + Extremum(bool poppable) => this.poppable = poppable; public override (bool, T) New() => default; public override void Restart(ref (bool, T) store) => store = default; @@ -294,7 +294,7 @@ public override IEnumerable GetEnumerable((bool, T) store) => public override void Add(ref (bool, T) store, int? limit, T item) { - if (!_poppable && store is (true, _)) + if (!this.poppable && store is (true, _)) return; store = (true, item); } diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs index f6cb840c4..3bd52ec81 100644 --- a/MoreLinq/Permutations.cs +++ b/MoreLinq/Permutations.cs @@ -67,48 +67,48 @@ sealed class PermutationEnumerator : IEnumerator> // for( int j = 0; j < 8; j++ ) // DoSomething(); - readonly IList _valueSet; - readonly int[] _permutation; - readonly IEnumerable _generator; + readonly IList valueSet; + readonly int[] permutation; + readonly IEnumerable generator; - IEnumerator _generatorIterator; - bool _hasMoreResults; + IEnumerator generatorIterator; + bool hasMoreResults; - IList? _current; + IList? current; public PermutationEnumerator(IEnumerable valueSet) { - _valueSet = valueSet.ToArray(); - _permutation = new int[_valueSet.Count]; + this.valueSet = valueSet.ToArray(); + this.permutation = new int[this.valueSet.Count]; // The nested loop construction below takes into account the fact that: // 1) for empty sets and sets of cardinality 1, there exists only a single permutation. // 2) for sets larger than 1 element, the number of nested loops needed is: set.Count-1 - _generator = NestedLoops(NextPermutation, Generate(2UL, n => n + 1).Take(Math.Max(0, _valueSet.Count - 1))); + this.generator = NestedLoops(NextPermutation, Generate(2UL, n => n + 1).Take(Math.Max(0, this.valueSet.Count - 1))); Reset(); } - [MemberNotNull(nameof(_generatorIterator))] + [MemberNotNull(nameof(generatorIterator))] public void Reset() { - _current = null; - _generatorIterator?.Dispose(); + this.current = null; + this.generatorIterator?.Dispose(); // restore lexographic ordering of the permutation indexes - for (var i = 0; i < _permutation.Length; i++) - _permutation[i] = i; + for (var i = 0; i < this.permutation.Length; i++) + this.permutation[i] = i; // start a new iteration over the nested loop generator - _generatorIterator = _generator.GetEnumerator(); + this.generatorIterator = this.generator.GetEnumerator(); // we must advance the nested loop iterator to the initial element, // this ensures that we only ever produce N!-1 calls to NextPermutation() - _ = _generatorIterator.MoveNext(); - _hasMoreResults = true; // there's always at least one permutation: the original set itself + _ = this.generatorIterator.MoveNext(); + this.hasMoreResults = true; // there's always at least one permutation: the original set itself } public IList Current { get { - Debug.Assert(_current is not null); - return _current; + Debug.Assert(this.current is not null); + return this.current; } } @@ -116,12 +116,12 @@ public IList Current public bool MoveNext() { - _current = PermuteValueSet(); + this.current = PermuteValueSet(); // check if more permutation left to enumerate - var prevResult = _hasMoreResults; - _hasMoreResults = _generatorIterator.MoveNext(); - if (_hasMoreResults) - _generatorIterator.Current(); // produce the next permutation ordering + var prevResult = this.hasMoreResults; + this.hasMoreResults = this.generatorIterator.MoveNext(); + if (this.hasMoreResults) + this.generatorIterator.Current(); // produce the next permutation ordering // we return prevResult rather than m_HasMoreResults because there is always // at least one permutation: the original set. Also, this provides a simple way // to deal with the disparity between sets that have only one loop level (size 0-2) @@ -129,7 +129,7 @@ public bool MoveNext() return prevResult; } - void IDisposable.Dispose() => _generatorIterator.Dispose(); + void IDisposable.Dispose() => this.generatorIterator.Dispose(); /// /// Transposes elements in the cached permutation array to produce the next permutation @@ -137,21 +137,21 @@ public bool MoveNext() void NextPermutation() { // find the largest index j with m_Permutation[j] < m_Permutation[j+1] - var j = _permutation.Length - 2; - while (_permutation[j] > _permutation[j + 1]) + var j = this.permutation.Length - 2; + while (this.permutation[j] > this.permutation[j + 1]) j--; // find index k such that m_Permutation[k] is the smallest integer // greater than m_Permutation[j] to the right of m_Permutation[j] - var k = _permutation.Length - 1; - while (_permutation[j] > _permutation[k]) + var k = this.permutation.Length - 1; + while (this.permutation[j] > this.permutation[k]) k--; - (_permutation[j], _permutation[k]) = (_permutation[k], _permutation[j]); + (this.permutation[j], this.permutation[k]) = (this.permutation[k], this.permutation[j]); // move the tail of the permutation after the jth position in increasing order - for (int x = _permutation.Length - 1, y = j + 1; x > y; x--, y++) - (_permutation[x], _permutation[y]) = (_permutation[y], _permutation[x]); + for (int x = this.permutation.Length - 1, y = j + 1; x > y; x--, y++) + (this.permutation[x], this.permutation[y]) = (this.permutation[y], this.permutation[x]); } /// @@ -170,9 +170,9 @@ void NextPermutation() /// Array of permuted source sequence values T[] PermuteValueSet() { - var permutedSet = new T[_permutation.Length]; - for (var i = 0; i < _permutation.Length; i++) - permutedSet[i] = _valueSet[_permutation[i]]; + var permutedSet = new T[this.permutation.Length]; + for (var i = 0; i < this.permutation.Length; i++) + permutedSet[i] = this.valueSet[this.permutation[i]]; return permutedSet; } } diff --git a/MoreLinq/Reactive/Subject.cs b/MoreLinq/Reactive/Subject.cs index 40f2ed6d2..e4dcc323c 100644 --- a/MoreLinq/Reactive/Subject.cs +++ b/MoreLinq/Reactive/Subject.cs @@ -23,26 +23,26 @@ namespace MoreLinq.Reactive sealed class Subject : IObservable, IObserver { - List>? _observers; - bool _completed; - Exception? _error; + List>? observers; + bool completed; + Exception? error; - bool HasObservers => (_observers?.Count ?? 0) > 0; - List> Observers => _observers ??= []; + bool HasObservers => (this.observers?.Count ?? 0) > 0; + List> Observers => this.observers ??= []; - bool IsMuted => _completed || _error != null; + bool IsMuted => this.completed || this.error != null; public IDisposable Subscribe(IObserver observer) { if (observer == null) throw new ArgumentNullException(nameof(observer)); - if (_error != null) + if (this.error != null) { - observer.OnError(_error); + observer.OnError(this.error); return Disposable.Nop; } - if (_completed) + if (this.completed) { observer.OnCompleted(); return Disposable.Nop; @@ -65,7 +65,7 @@ public IDisposable Subscribe(IObserver observer) { if (observers[i] == observer) { - if (_shouldDeleteObserver) + if (this.shouldDeleteObserver) observers[i] = null!; else observers.RemoveAt(i); @@ -75,7 +75,7 @@ public IDisposable Subscribe(IObserver observer) }); } - bool _shouldDeleteObserver; // delete (null) or remove an observer? + bool shouldDeleteObserver; // delete (null) or remove an observer? public void OnNext(T value) { @@ -89,7 +89,7 @@ public void OnNext(T value) // instead of being removed from the list of observers. The actual // removal is then deferred until after the iteration is complete. - _shouldDeleteObserver = true; + this.shouldDeleteObserver = true; try { @@ -104,7 +104,7 @@ public void OnNext(T value) } finally { - _shouldDeleteObserver = false; + this.shouldDeleteObserver = false; // Remove any observers that were marked for deletion during // iteration. @@ -114,10 +114,10 @@ public void OnNext(T value) } public void OnError(Exception error) => - OnFinality(ref _error, error, (observer, err) => observer.OnError(err)); + OnFinality(ref this.error, error, (observer, err) => observer.OnError(err)); public void OnCompleted() => - OnFinality(ref _completed, true, (observer, _) => observer.OnCompleted()); + OnFinality(ref this.completed, true, (observer, _) => observer.OnCompleted()); void OnFinality(ref TState? state, TState value, Action, TState> action) { @@ -130,8 +130,8 @@ void OnFinality(ref TState? state, TState value, Action, TS // to be called so release the list of observers of this subject. // The list of observers will be garbage once this method returns. - var observers = _observers; - _observers = null; + var observers = this.observers; + this.observers = null; if (observers == null) return; diff --git a/MoreLinq/Return.cs b/MoreLinq/Return.cs index 078d5beb7..7da8be861 100644 --- a/MoreLinq/Return.cs +++ b/MoreLinq/Return.cs @@ -34,24 +34,24 @@ partial class MoreEnumerable sealed class SingleElementList(T item) : IList, IReadOnlyList { - readonly T _item = item; + readonly T item = item; public int Count => 1; public bool IsReadOnly => true; public T this[int index] { - get => index == 0 ? _item : throw new ArgumentOutOfRangeException(nameof(index)); + get => index == 0 ? this.item : throw new ArgumentOutOfRangeException(nameof(index)); set => throw ReadOnlyException(); } - public IEnumerator GetEnumerator() { yield return _item; } + public IEnumerator GetEnumerator() { yield return this.item; } IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); public int IndexOf(T item) => Contains(item) ? 0 : -1; - public bool Contains(T item) => EqualityComparer.Default.Equals(_item, item); + public bool Contains(T item) => EqualityComparer.Default.Equals(this.item, item); - public void CopyTo(T[] array, int arrayIndex) => array[arrayIndex] = _item; + public void CopyTo(T[] array, int arrayIndex) => array[arrayIndex] = this.item; // Following methods are unsupported as this is a read-only list. diff --git a/MoreLinq/ReverseComparer.cs b/MoreLinq/ReverseComparer.cs index e80749bcd..9f96c1bdc 100644 --- a/MoreLinq/ReverseComparer.cs +++ b/MoreLinq/ReverseComparer.cs @@ -21,7 +21,7 @@ namespace MoreLinq sealed class ReverseComparer(IComparer? underlying) : IComparer { - readonly IComparer _underlying = underlying ?? Comparer.Default; + readonly IComparer underlying = underlying ?? Comparer.Default; public int Compare #if NETCOREAPP3_1_OR_GREATER @@ -30,7 +30,7 @@ public int Compare (T x, T y) #endif { - var result = _underlying.Compare(x, y); + var result = this.underlying.Compare(x, y); return result < 0 ? 1 : result > 0 ? -1 : 0; } } diff --git a/MoreLinq/Subsets.cs b/MoreLinq/Subsets.cs index 41c75eb6c..b5b79cb22 100644 --- a/MoreLinq/Subsets.cs +++ b/MoreLinq/Subsets.cs @@ -132,16 +132,16 @@ sealed class SubsetGenerator : IEnumerable> sealed class SubsetEnumerator : IEnumerator> { - readonly IList _set; // the original set of elements - readonly T[] _subset; // the current subset to return - readonly int[] _indices; // indices into the original set + readonly IList set; // the original set of elements + readonly T[] subset; // the current subset to return + readonly int[] indices; // indices into the original set - bool _continue; // termination indicator, set when all subsets have been produced + bool @continue; // termination indicator, set when all subsets have been produced - int _prevSwapIndex; // previous swap index (upper index) - int _currSwapIndex; // current swap index (lower index) - int _subsetSize; // size of the subset being produced - int _setSize; // size of the original set (sequence) + int prevSwapIndex; // previous swap index (upper index) + int currSwapIndex; // current swap index (lower index) + int subsetSize; // size of the subset being produced + int setSize; // size of the original set (sequence) public SubsetEnumerator(IList set, int subsetSize) { @@ -150,53 +150,54 @@ public SubsetEnumerator(IList set, int subsetSize) throw new ArgumentOutOfRangeException(nameof(subsetSize), "Subset size must be <= sequence.Count()"); // initialize set arrays... - _set = set; - _subset = new T[subsetSize]; - _indices = new int[subsetSize]; + this.set = set; + this.subset = new T[subsetSize]; + this.indices = new int[subsetSize]; // initialize index counters... Reset(); } public void Reset() { - _prevSwapIndex = _subset.Length; - _currSwapIndex = -1; - _subsetSize = _subset.Length; - _setSize = _set.Count; - _continue = true; + this.prevSwapIndex = this.subset.Length; + this.currSwapIndex = -1; + this.subsetSize = this.subset.Length; + this.setSize = this.set.Count; + this.@continue = true; } - public IList Current => (IList)_subset.Clone(); + public IList Current => (IList)this.subset.Clone(); object IEnumerator.Current => Current; public bool MoveNext() { - if (!_continue) + if (!this.@continue) return false; - if (_currSwapIndex == -1) + if (this.currSwapIndex == -1) { - _currSwapIndex = 0; - _prevSwapIndex = _subsetSize; + this.currSwapIndex = 0; + this.prevSwapIndex = this.subsetSize; } else { - if (_currSwapIndex < _setSize - _prevSwapIndex) + if (this.currSwapIndex < this.setSize - this.prevSwapIndex) { - _prevSwapIndex = 0; + this.prevSwapIndex = 0; } - _prevSwapIndex++; - _currSwapIndex = _indices[_subsetSize - _prevSwapIndex]; + this.prevSwapIndex++; + this.currSwapIndex = this.indices[this.subsetSize - this.prevSwapIndex]; } - for (var j = 1; j <= _prevSwapIndex; j++) - _indices[_subsetSize + j - _prevSwapIndex - 1] = _currSwapIndex + j; + for (var j = 1; j <= this.prevSwapIndex; j++) + this.indices[this.subsetSize + j - this.prevSwapIndex - 1] = this.currSwapIndex + j; ExtractSubset(); - // ........................................ count of items excluded from the subset - _continue = _indices is [var i, ..] && i != _setSize - _subsetSize + 1; + this.@continue = this.indices is [var i, ..] + // .... count of items excluded from the subset + && i != this.setSize - this.subsetSize + 1; return true; } @@ -205,13 +206,13 @@ void IDisposable.Dispose() { } void ExtractSubset() { - for (var i = 0; i < _subsetSize; i++) - _subset[i] = _set[_indices[i] - 1]; + for (var i = 0; i < this.subsetSize; i++) + this.subset[i] = this.set[this.indices[i] - 1]; } } - readonly IEnumerable _sequence; - readonly int _subsetSize; + readonly IEnumerable sequence; + readonly int subsetSize; public SubsetGenerator(IEnumerable sequence, int subsetSize) { @@ -219,8 +220,8 @@ public SubsetGenerator(IEnumerable sequence, int subsetSize) throw new ArgumentNullException(nameof(sequence)); if (subsetSize < 0) throw new ArgumentOutOfRangeException(nameof(subsetSize), "{subsetSize} must be between 0 and set.Count()"); - _subsetSize = subsetSize; - _sequence = sequence; + this.subsetSize = subsetSize; + this.sequence = sequence; } /// @@ -232,7 +233,7 @@ public SubsetGenerator(IEnumerable sequence, int subsetSize) public IEnumerator> GetEnumerator() { - return new SubsetEnumerator(_sequence.ToList(), _subsetSize); + return new SubsetEnumerator(this.sequence.ToList(), this.subsetSize); } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } From 3a3c256dd603d02b0e880dd1ffbd7fcba8a87454 Mon Sep 17 00:00:00 2001 From: Julien Aspirot Date: Sun, 19 Nov 2023 13:40:57 -0500 Subject: [PATCH 129/157] Add "Duplicates" extension This is a squashed merge of PR #1037 that partially addresses #125. --------- Co-authored-by: Atif Aziz --- MoreLinq.Test/DuplicatesTest.cs | 105 ++++++++++++++++++ MoreLinq/Duplicates.cs | 64 +++++++++++ MoreLinq/Extensions.g.cs | 35 ++++++ MoreLinq/MoreLinq.csproj | 1 + .../PublicAPI/net6.0/PublicAPI.Unshipped.txt | 5 + .../PublicAPI/net8.0/PublicAPI.Unshipped.txt | 5 + .../netstandard2.0/PublicAPI.Unshipped.txt | 5 + .../netstandard2.1/PublicAPI.Unshipped.txt | 5 + README.md | 6 + bld/Copyright.props | 1 + 10 files changed, 232 insertions(+) create mode 100644 MoreLinq.Test/DuplicatesTest.cs create mode 100644 MoreLinq/Duplicates.cs diff --git a/MoreLinq.Test/DuplicatesTest.cs b/MoreLinq.Test/DuplicatesTest.cs new file mode 100644 index 000000000..2b97f471e --- /dev/null +++ b/MoreLinq.Test/DuplicatesTest.cs @@ -0,0 +1,105 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2023 Julien Aspirot. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq.Test +{ + using System.Collections.Generic; + using NUnit.Framework; + using Delegate = Delegating.Delegate; + + [TestFixture] + public class DuplicatesTest + { + [Test] + public void Duplicates_IsLazy() + { + _ = new BreakingSequence().Duplicates(); + } + + [Test] + public void Streams_Duplicates_As_They_Are_Discovered() + { + static IEnumerable Source() + { + yield return "DUPLICATED_STRING"; + yield return "DUPLICATED_STRING"; + throw new TestException(); + } + + using var source = Source().AsTestingSequence(); + + var results = source.Duplicates().Take(1).ToArray(); + + Assert.That(results, Is.EqualTo(new[] { "DUPLICATED_STRING" })); + } + + [Test] + public void Sequence_Without_Duplicates_Returns_Empty_Sequence() + { + using var input = TestingSequence.Of("FirstElement", "SecondElement", "ThirdElement"); + + var results = input.Duplicates().ToArray(); + + Assert.That(results, Is.Empty); + } + + [Test] + public void Sequence_With_Duplicates_Returns_Duplicates() + { + using var input = + TestingSequence.Of("FirstElement", + "DUPLICATED_STRING", + "DUPLICATED_STRING", + "DUPLICATED_STRING", + "ThirdElement"); + + var results = input.Duplicates().ToArray(); + + Assert.That(results, Contains.Item("DUPLICATED_STRING")); + Assert.That(results, Has.Exactly(1).Items); + } + + [Test] + public void Sequence_With_Multiple_Duplicates_Returns_One_Instance_Of_Each_Duplicates() + { + using var input = + TestingSequence.Of("FirstElement", + "DUPLICATED_STRING", + "DUPLICATED_STRING", + "DUPLICATED_STRING", + "ThirdElement", + "SECOND_DUPLICATED_STRING", + "SECOND_DUPLICATED_STRING"); + + var results = input.Duplicates().ToArray(); + + Assert.That(results, Contains.Item("DUPLICATED_STRING")); + Assert.That(results, Contains.Item("SECOND_DUPLICATED_STRING")); + Assert.That(results, Has.Exactly(2).Items); + } + + [Test] + public void Sequence_With_Duplicates_But_Using_Comparer_That_Always_Return_False_Returns_Empty_Sequence() + { + using var input = TestingSequence.Of("DUPLICATED_STRING", "DUPLICATED_STRING", "DUPLICATED_STRING"); + + var results = input.Duplicates(Delegate.EqualityComparer((_, _) => false, (string _) => 0)); + + Assert.That(results, Is.Empty); + } + } +} diff --git a/MoreLinq/Duplicates.cs b/MoreLinq/Duplicates.cs new file mode 100644 index 000000000..b29f9a65d --- /dev/null +++ b/MoreLinq/Duplicates.cs @@ -0,0 +1,64 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2023 Julien Aspirot. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq +{ + using System; + using System.Collections.Generic; + using System.Linq; + + static partial class MoreEnumerable + { + /// + /// Returns all duplicate elements of the given source. + /// + /// The source sequence. + /// The type of the elements in the source sequence. + /// is . + /// All elements that are duplicated. + /// This operator uses deferred execution and streams its results. + + public static IEnumerable Duplicates(this IEnumerable source) => + Duplicates(source, null); + + /// + /// Returns all duplicate elements of the given source, using the specified equality + /// comparer. + /// + /// The source sequence. + /// + /// The equality comparer to use to determine whether one + /// equals another. If , the default equality comparer for + /// is used. + /// The type of the elements in the source sequence. + /// is . + /// All elements that are duplicated. + /// This operator uses deferred execution and streams its results. + + public static IEnumerable Duplicates(this IEnumerable source, IEqualityComparer? comparer) + { + if (source is null) throw new ArgumentNullException(nameof(source)); + + return from e in source.ScanBy(static e => e, + static _ => 0, + static (count, _, _) => unchecked(Math.Min(count + 1, 3)), + comparer) + where e.Value is 2 + select e.Key; + } + } +} diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index b7fcf096d..83b2e90ac 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -1283,6 +1283,41 @@ public static IEnumerable DistinctBy(this IEnumerableDuplicates extension. + + [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")] + public static partial class DuplicatesExtension + { + /// + /// Returns all duplicate elements of the given source. + /// + /// The source sequence. + /// The type of the elements in the source sequence. + /// is . + /// All elements that are duplicated. + /// This operator uses deferred execution and streams its results. + + public static IEnumerable Duplicates(this IEnumerable source) => MoreEnumerable.Duplicates(source); + + /// + /// Returns all duplicate elements of the given source, using the specified equality + /// comparer. + /// + /// The source sequence. + /// + /// The equality comparer to use to determine whether one + /// equals another. If , the default equality comparer for + /// is used. + /// The type of the elements in the source sequence. + /// is . + /// All elements that are duplicated. + /// This operator uses deferred execution and streams its results. + + public static IEnumerable Duplicates(this IEnumerable source, IEqualityComparer? comparer) + => MoreEnumerable.Duplicates(source, comparer); + + } + /// EndsWith extension. [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")] diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 6671f4934..38d48eee5 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -27,6 +27,7 @@ - CountDown - Consume - DistinctBy + - Duplicates - EndsWith - EquiZip - Evaluate diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt index 7dc5c5811..cada4690e 100644 --- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt @@ -1 +1,6 @@ #nullable enable +MoreLinq.Extensions.DuplicatesExtension +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt index ce7910980..057e63bee 100644 --- a/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt @@ -30,6 +30,7 @@ MoreLinq.Extensions.CountBetweenExtension MoreLinq.Extensions.CountByExtension MoreLinq.Extensions.CountDownExtension MoreLinq.Extensions.DistinctByExtension +MoreLinq.Extensions.DuplicatesExtension MoreLinq.Extensions.EndsWithExtension MoreLinq.Extensions.EquiZipExtension MoreLinq.Extensions.EvaluateExtension @@ -183,6 +184,8 @@ static MoreLinq.Extensions.CountByExtension.CountBy(this System.C static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -441,6 +444,8 @@ static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Ge static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt index 7dc5c5811..cada4690e 100644 --- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt @@ -1 +1,6 @@ #nullable enable +MoreLinq.Extensions.DuplicatesExtension +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt index 7dc5c5811..cada4690e 100644 --- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt @@ -1 +1,6 @@ #nullable enable +MoreLinq.Extensions.DuplicatesExtension +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! diff --git a/README.md b/README.md index 98d40de8a..2a897f211 100644 --- a/README.md +++ b/README.md @@ -206,6 +206,12 @@ projected type. This method has 2 overloads. +### Duplicates + +Returns all duplicate elements of the given source. + +This method has 2 overloads. + ### EndsWith Determines whether the end of the first sequence is equivalent to the second diff --git a/bld/Copyright.props b/bld/Copyright.props index 62e21672d..96a381457 100644 --- a/bld/Copyright.props +++ b/bld/Copyright.props @@ -7,6 +7,7 @@ Portions © 2015 Felipe Sateler, “sholland”. Portions © 2016 Andreas Gullberg Larsen, Leandro F. Vieira (leandromoh). Portions © 2017 Jonas Nyrup (jnyrup). + Portions © 2023 Julien Aspirot (julienasp). Portions © Microsoft. All rights reserved. From c349f1dacac1c074a1913c95ce1046e612214363 Mon Sep 17 00:00:00 2001 From: Stuart Turner Date: Mon, 20 Nov 2023 00:38:28 -0600 Subject: [PATCH 130/157] Hide "ToDictionary" in .NET 8+ This is a squashed merge of PR #1040 that close #1012. --------- Co-authored-by: Atif Aziz --- MoreLinq.Test/ToDictionaryTest.cs | 8 +++--- MoreLinq/CompatibilitySuppressions.xml | 24 +++++++++++++++++ .../PublicAPI/net8.0/PublicAPI.Unshipped.txt | 8 +++--- MoreLinq/ToDictionary.cs | 26 +++++++++++++++++-- 4 files changed, 56 insertions(+), 10 deletions(-) diff --git a/MoreLinq.Test/ToDictionaryTest.cs b/MoreLinq.Test/ToDictionaryTest.cs index e4a1f8ad6..5bd5f87b9 100644 --- a/MoreLinq.Test/ToDictionaryTest.cs +++ b/MoreLinq.Test/ToDictionaryTest.cs @@ -33,7 +33,7 @@ public void ToDictionaryWithKeyValuePairs() KeyValuePair.Create("baz", 789), }; - var dict = pairs.ToDictionary(); + var dict = MoreEnumerable.ToDictionary(pairs); Assert.That(dict["foo"], Is.EqualTo(123)); Assert.That(dict["bar"], Is.EqualTo(456)); @@ -50,7 +50,7 @@ public void ToDictionaryWithCouples() ("baz", 789), }; - var dict = pairs.ToDictionary(); + var dict = MoreEnumerable.ToDictionary(pairs); Assert.That(dict["foo"], Is.EqualTo(123)); Assert.That(dict["bar"], Is.EqualTo(456)); @@ -67,7 +67,7 @@ public void ToDictionaryWithKeyValuePairsWithComparer() KeyValuePair.Create("baz", 789), }; - var dict = pairs.ToDictionary(StringComparer.OrdinalIgnoreCase); + var dict = MoreEnumerable.ToDictionary(pairs, StringComparer.OrdinalIgnoreCase); Assert.That(dict["FOO"], Is.EqualTo(123)); Assert.That(dict["BAR"], Is.EqualTo(456)); @@ -84,7 +84,7 @@ public void ToDictionaryWithCouplesWithComparer() ("baz", 789), }; - var dict = pairs.ToDictionary(StringComparer.OrdinalIgnoreCase); + var dict = MoreEnumerable.ToDictionary(pairs, StringComparer.OrdinalIgnoreCase); Assert.That(dict["FOO"], Is.EqualTo(123)); Assert.That(dict["BAR"], Is.EqualTo(456)); diff --git a/MoreLinq/CompatibilitySuppressions.xml b/MoreLinq/CompatibilitySuppressions.xml index 1b532b5f8..b7cc8ddaf 100644 --- a/MoreLinq/CompatibilitySuppressions.xml +++ b/MoreLinq/CompatibilitySuppressions.xml @@ -1,6 +1,30 @@ + + CP0002 + M:MoreLinq.MoreEnumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) + lib/net6.0/MoreLinq.dll + lib/net8.0/MoreLinq.dll + + + CP0002 + M:MoreLinq.MoreEnumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{``0,``1}}) + lib/net6.0/MoreLinq.dll + lib/net8.0/MoreLinq.dll + + + CP0002 + M:MoreLinq.MoreEnumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}},System.Collections.Generic.IEqualityComparer{``0}) + lib/net6.0/MoreLinq.dll + lib/net8.0/MoreLinq.dll + + + CP0002 + M:MoreLinq.MoreEnumerable.ToDictionary``2(System.Collections.Generic.IEnumerable{System.ValueTuple{``0,``1}}) + lib/net6.0/MoreLinq.dll + lib/net8.0/MoreLinq.dll + CP0002 M:MoreLinq.SequenceException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext) diff --git a/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt index 057e63bee..d13530e3e 100644 --- a/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt @@ -661,10 +661,10 @@ static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! diff --git a/MoreLinq/ToDictionary.cs b/MoreLinq/ToDictionary.cs index 47db8bf76..a0e6d87d1 100644 --- a/MoreLinq/ToDictionary.cs +++ b/MoreLinq/ToDictionary.cs @@ -35,9 +35,14 @@ static partial class MoreEnumerable /// mapped to their keys. /// +#if !NET8_0_OR_GREATER public static Dictionary ToDictionary(this IEnumerable> source) where TKey : notnull => - source.ToDictionary(null); +#else + public static Dictionary ToDictionary(IEnumerable> source) + where TKey : notnull => +#endif + ToDictionary(source, null); /// /// Creates a from a sequence of @@ -53,9 +58,15 @@ public static Dictionary ToDictionary(this IEnumerab /// mapped to their keys. /// +#if !NET8_0_OR_GREATER public static Dictionary ToDictionary(this IEnumerable> source, IEqualityComparer? comparer) where TKey : notnull +#else + public static Dictionary ToDictionary(IEnumerable> source, + IEqualityComparer? comparer) + where TKey : notnull +#endif { if (source == null) throw new ArgumentNullException(nameof(source)); return source.ToDictionary(e => e.Key, e => e.Value, comparer); @@ -74,9 +85,14 @@ public static Dictionary ToDictionary(this IEnumerab /// mapped to their keys. /// +#if !NET8_0_OR_GREATER public static Dictionary ToDictionary(this IEnumerable<(TKey Key, TValue Value)> source) where TKey : notnull => - source.ToDictionary(null); +#else + public static Dictionary ToDictionary(IEnumerable<(TKey Key, TValue Value)> source) + where TKey : notnull => +#endif + ToDictionary(source, null); /// /// Creates a from a sequence of @@ -92,9 +108,15 @@ public static Dictionary ToDictionary(this IEnumerab /// mapped to their keys. /// +#if !NET8_0_OR_GREATER public static Dictionary ToDictionary(this IEnumerable<(TKey Key, TValue Value)> source, IEqualityComparer? comparer) where TKey : notnull +#else + public static Dictionary ToDictionary(IEnumerable<(TKey Key, TValue Value)> source, + IEqualityComparer? comparer) + where TKey : notnull +#endif { if (source == null) throw new ArgumentNullException(nameof(source)); return source.ToDictionary(e => e.Key, e => e.Value, comparer); From a263661f61ffc11ecad07f3a6f8fe2418a68f774 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 19 Nov 2023 15:23:04 +0100 Subject: [PATCH 131/157] Use "EqualityComparer.Create" from .NET 8 --- MoreLinq.Test/EndsWithTest.cs | 4 ++-- MoreLinq.Test/EqualityComparer.cs | 15 +++++++++++---- MoreLinq.Test/PermutationsTest.cs | 2 +- MoreLinq.Test/StartsWithTest.cs | 4 ++-- 4 files changed, 16 insertions(+), 9 deletions(-) diff --git a/MoreLinq.Test/EndsWithTest.cs b/MoreLinq.Test/EndsWithTest.cs index 108980360..11add633c 100644 --- a/MoreLinq.Test/EndsWithTest.cs +++ b/MoreLinq.Test/EndsWithTest.cs @@ -87,8 +87,8 @@ public void EndsWithUsesSpecifiedEqualityComparerOrDefault() Assert.That(first.EndsWith(second), Is.False); Assert.That(first.EndsWith(second, null), Is.False); - Assert.That(first.EndsWith(second, EqualityComparer.Create(delegate { return false; })), Is.False); - Assert.That(first.EndsWith(second, EqualityComparer.Create(delegate { return true; })), Is.True); + Assert.That(first.EndsWith(second, EqualityComparer.Create(delegate { return false; })), Is.False); + Assert.That(first.EndsWith(second, EqualityComparer.Create(delegate { return true; })), Is.True); } [TestCase(SourceKind.BreakingCollection)] diff --git a/MoreLinq.Test/EqualityComparer.cs b/MoreLinq.Test/EqualityComparer.cs index 59245b170..6763858a3 100644 --- a/MoreLinq.Test/EqualityComparer.cs +++ b/MoreLinq.Test/EqualityComparer.cs @@ -15,22 +15,27 @@ // limitations under the License. #endregion +#if !NET8_0_OR_GREATER + namespace MoreLinq.Test { using System; using System.Collections.Generic; - static class EqualityComparer + static class EqualityComparer { + public static System.Collections.Generic.EqualityComparer + Default => System.Collections.Generic.EqualityComparer.Default; + /// /// Creates an given a /// . /// - public static IEqualityComparer Create(Func comparer) => - new DelegatingComparer(comparer); + public static IEqualityComparer Create(Func comparer) => + new DelegatingComparer(comparer); - sealed class DelegatingComparer : IEqualityComparer + sealed class DelegatingComparer : IEqualityComparer { readonly Func comparer; readonly Func hasher; @@ -49,3 +54,5 @@ public DelegatingComparer(Func comparer) } } } + +#endif diff --git a/MoreLinq.Test/PermutationsTest.cs b/MoreLinq.Test/PermutationsTest.cs index 44571c6fa..6941bc778 100644 --- a/MoreLinq.Test/PermutationsTest.cs +++ b/MoreLinq.Test/PermutationsTest.cs @@ -200,7 +200,7 @@ public void TestPermutationsAreIndependent() static class SequenceEqualityComparer { public static readonly IEqualityComparer> Instance = - EqualityComparer.Create>((x, y) => x is { } sx && y is { } sy && sx.SequenceEqual(sy)); + EqualityComparer>.Create((x, y) => x is { } sx && y is { } sy && sx.SequenceEqual(sy)); } } } diff --git a/MoreLinq.Test/StartsWithTest.cs b/MoreLinq.Test/StartsWithTest.cs index 00b386d1b..cb4148b52 100644 --- a/MoreLinq.Test/StartsWithTest.cs +++ b/MoreLinq.Test/StartsWithTest.cs @@ -87,8 +87,8 @@ public void StartsWithUsesSpecifiedEqualityComparerOrDefault() Assert.That(first.StartsWith(second), Is.False); Assert.That(first.StartsWith(second, null), Is.False); - Assert.That(first.StartsWith(second, EqualityComparer.Create(delegate { return false; })), Is.False); - Assert.That(first.StartsWith(second, EqualityComparer.Create(delegate { return true; })), Is.True); + Assert.That(first.StartsWith(second, EqualityComparer.Create(delegate { return false; })), Is.False); + Assert.That(first.StartsWith(second, EqualityComparer.Create(delegate { return true; })), Is.True); } [TestCase(SourceKind.BreakingCollection)] From 2a7257731b7ec96aa602c77ff2e6c61450f79a0d Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Tue, 21 Nov 2023 21:01:20 +0100 Subject: [PATCH 132/157] Refactor "Subsets" core into an iterator method --- MoreLinq.Test/SubsetTest.cs | 24 +++++ MoreLinq/Subsets.cs | 172 +++++++++++------------------------- 2 files changed, 75 insertions(+), 121 deletions(-) diff --git a/MoreLinq.Test/SubsetTest.cs b/MoreLinq.Test/SubsetTest.cs index ef079e166..3d0fb27ce 100644 --- a/MoreLinq.Test/SubsetTest.cs +++ b/MoreLinq.Test/SubsetTest.cs @@ -193,5 +193,29 @@ public void TestKSubsetExpectedResult() foreach (var subset in result) Assert.That(subset, Is.EqualTo(expectedSubsets[index++])); } + + [Test(Description = "https://github.com/morelinq/MoreLINQ/issues/1047")] + public void TestEnumeratorCurrentReturnsSameReferenceOnEachAccess() + { + var source = Seq(1, 2, 3, 4, 5); + + using var e = source.Subsets(3).GetEnumerator(); + var moved = e.MoveNext(); + var first = e.Current; + var second = e.Current; + + Assert.That(moved, Is.True); + Assert.That(first, Is.SameAs(second)); + } + + [Test] + public void TestEachSubsetInstanceIsUnique() + { + var source = Seq(1, 2, 3, 4, 5); + + var subsets = source.Subsets(2).ToArray(); + + Assert.That(subsets[0], Is.Not.SameAs(subsets[1])); + } } } diff --git a/MoreLinq/Subsets.cs b/MoreLinq/Subsets.cs index b5b79cb22..f1167152f 100644 --- a/MoreLinq/Subsets.cs +++ b/MoreLinq/Subsets.cs @@ -18,7 +18,6 @@ namespace MoreLinq { using System; - using System.Collections; using System.Collections.Generic; using System.Linq; @@ -57,23 +56,22 @@ public static IEnumerable> Subsets(this IEnumerable sequence) var sequenceAsList = sequence.ToList(); var sequenceLength = sequenceAsList.Count; - // the first subset is the empty set - yield return new List(); + yield return []; // the first subset is the empty set - // all other subsets are computed using the subset generator - // this check also resolves the case of permuting empty sets - if (sequenceLength > 0) + // next check also resolves the case of permuting empty sets + if (sequenceLength is 0) + yield break; + + // all other subsets are computed using the subset generator... + + for (var k = 1; k < sequenceLength; k++) { - for (var i = 1; i < sequenceLength; i++) - { - // each intermediate subset is a lexographically ordered K-subset - var subsetGenerator = new SubsetGenerator(sequenceAsList, i); - foreach (var subset in subsetGenerator) - yield return subset; - } - - yield return sequenceAsList; // the last subset is the original set itself + // each intermediate subset is a lexographically ordered K-subset + foreach (var subset in Subsets(sequenceAsList, k)) + yield return subset; } + + yield return sequenceAsList; // the last subset is the original set itself } } @@ -115,128 +113,60 @@ public static IEnumerable> Subsets(this IEnumerable sequence, int // preconditions. This however, needs to be carefully considered - and perhaps // may change after further thought and review. - return new SubsetGenerator(sequence, subsetSize); + return _(); IEnumerable> _() + { + foreach (var subset in Subsets(sequence.ToList(), subsetSize)) + yield return subset; + } } - /// - /// This class is responsible for producing the lexographically ordered k-subsets + /// Produces lexographically ordered k-subsets. /// + /// + /// It uses a snapshot of the original sequence, and an iterative, + /// reductive swap algorithm to produce all subsets of a predetermined + /// size less than or equal to the original set size. + /// - sealed class SubsetGenerator : IEnumerable> + static IEnumerable> Subsets(List set, int subsetSize) { - /// - /// SubsetEnumerator uses a snapshot of the original sequence, and an - /// iterative, reductive swap algorithm to produce all subsets of a - /// predetermined size less than or equal to the original set size. - /// - - sealed class SubsetEnumerator : IEnumerator> - { - readonly IList set; // the original set of elements - readonly T[] subset; // the current subset to return - readonly int[] indices; // indices into the original set + // precondition: subsetSize <= set.Count + if (subsetSize > set.Count) + throw new ArgumentOutOfRangeException(nameof(subsetSize), "Subset size must be <= sequence.Count()"); - bool @continue; // termination indicator, set when all subsets have been produced - - int prevSwapIndex; // previous swap index (upper index) - int currSwapIndex; // current swap index (lower index) - int subsetSize; // size of the subset being produced - int setSize; // size of the original set (sequence) - - public SubsetEnumerator(IList set, int subsetSize) - { - // precondition: subsetSize <= set.Count - if (subsetSize > set.Count) - throw new ArgumentOutOfRangeException(nameof(subsetSize), "Subset size must be <= sequence.Count()"); - - // initialize set arrays... - this.set = set; - this.subset = new T[subsetSize]; - this.indices = new int[subsetSize]; - // initialize index counters... - Reset(); - } + var indices = new int[subsetSize]; // indices into the original set + var prevSwapIndex = subsetSize; // previous swap index (upper index) + var currSwapIndex = -1; // current swap index (lower index) + var setSize = set.Count; - public void Reset() + do + { + if (currSwapIndex == -1) { - this.prevSwapIndex = this.subset.Length; - this.currSwapIndex = -1; - this.subsetSize = this.subset.Length; - this.setSize = this.set.Count; - this.@continue = true; + currSwapIndex = 0; + prevSwapIndex = subsetSize; } - - public IList Current => (IList)this.subset.Clone(); - - object IEnumerator.Current => Current; - - public bool MoveNext() + else { - if (!this.@continue) - return false; - - if (this.currSwapIndex == -1) - { - this.currSwapIndex = 0; - this.prevSwapIndex = this.subsetSize; - } - else - { - if (this.currSwapIndex < this.setSize - this.prevSwapIndex) - { - this.prevSwapIndex = 0; - } - this.prevSwapIndex++; - this.currSwapIndex = this.indices[this.subsetSize - this.prevSwapIndex]; - } - - for (var j = 1; j <= this.prevSwapIndex; j++) - this.indices[this.subsetSize + j - this.prevSwapIndex - 1] = this.currSwapIndex + j; - - ExtractSubset(); - - this.@continue = this.indices is [var i, ..] - // .... count of items excluded from the subset - && i != this.setSize - this.subsetSize + 1; - - return true; - } - - void IDisposable.Dispose() { } + if (currSwapIndex < setSize - prevSwapIndex) + prevSwapIndex = 0; - void ExtractSubset() - { - for (var i = 0; i < this.subsetSize; i++) - this.subset[i] = this.set[this.indices[i] - 1]; + prevSwapIndex++; + currSwapIndex = indices[subsetSize - prevSwapIndex]; } - } - readonly IEnumerable sequence; - readonly int subsetSize; + for (var i = 1; i <= prevSwapIndex; i++) + indices[subsetSize + i - prevSwapIndex - 1] = currSwapIndex + i; - public SubsetGenerator(IEnumerable sequence, int subsetSize) - { - if (sequence is null) - throw new ArgumentNullException(nameof(sequence)); - if (subsetSize < 0) - throw new ArgumentOutOfRangeException(nameof(subsetSize), "{subsetSize} must be between 0 and set.Count()"); - this.subsetSize = subsetSize; - this.sequence = sequence; - } + var subset = new T[subsetSize]; // the current subset to return + for (var i = 0; i < subsetSize; i++) + subset[i] = set[indices[i] - 1]; - /// - /// Returns an enumerator that produces all of the k-sized - /// subsets of the initial value set. The enumerator returns - /// and for each subset. - /// - /// an that enumerates all k-sized subsets - - public IEnumerator> GetEnumerator() - { - return new SubsetEnumerator(this.sequence.ToList(), this.subsetSize); + yield return subset; } - - IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } + while (indices is [var fi, ..] + // .... count of items excluded from the subset + && fi != setSize - subsetSize + 1); } } } From 0149de67509747f434caaac41032e4b85adf080b Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Fri, 24 Nov 2023 00:06:13 +0100 Subject: [PATCH 133/157] Sort public API files --- .../PublicAPI/net6.0/PublicAPI.Shipped.txt | 272 ++++++++--------- .../PublicAPI/net6.0/PublicAPI.Unshipped.txt | 4 +- .../PublicAPI/net8.0/PublicAPI.Unshipped.txt | 276 +++++++++--------- .../netstandard2.0/PublicAPI.Shipped.txt | 270 ++++++++--------- .../netstandard2.0/PublicAPI.Unshipped.txt | 4 +- .../netstandard2.1/PublicAPI.Shipped.txt | 272 ++++++++--------- .../netstandard2.1/PublicAPI.Unshipped.txt | 4 +- 7 files changed, 551 insertions(+), 551 deletions(-) diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt index b393e18b7..0b7808937 100644 --- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt @@ -1,4 +1,10 @@ #nullable enable +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! MoreLinq.Experimental.Async.ExperimentalEnumerable MoreLinq.Experimental.AwaitQueryOptions MoreLinq.Experimental.AwaitQueryOptions.MaxConcurrency.get -> int? @@ -57,8 +63,8 @@ MoreLinq.Extensions.LastOrDefaultExtension MoreLinq.Extensions.LeadExtension MoreLinq.Extensions.LeftJoinExtension MoreLinq.Extensions.MaxByExtension -MoreLinq.Extensions.MinByExtension MoreLinq.Extensions.MaximaExtension +MoreLinq.Extensions.MinByExtension MoreLinq.Extensions.MinimaExtension MoreLinq.Extensions.MoveExtension MoreLinq.Extensions.OrderByExtension @@ -120,18 +126,18 @@ MoreLinq.OrderByDirection.Ascending = 0 -> MoreLinq.OrderByDirection MoreLinq.OrderByDirection.Descending = 1 -> MoreLinq.OrderByDirection MoreLinq.SequenceException MoreLinq.SequenceException.SequenceException() -> void -MoreLinq.SequenceException.SequenceException(string? message) -> 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.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.Collections.Generic.IAsyncEnumerable! static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.Collections.Generic.IAsyncEnumerable! -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.Collections.Generic.IAsyncEnumerable! static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential(this MoreLinq.Experimental.IAwaitQuery! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! @@ -159,10 +165,10 @@ static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! @@ -179,33 +185,33 @@ static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collec static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult @@ -226,24 +232,24 @@ static MoreLinq.Extensions.FoldExtension.Fold(this System.Collection static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -252,43 +258,43 @@ static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerabl static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult @@ -303,22 +309,22 @@ static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Col static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! @@ -326,8 +332,8 @@ static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Col static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -341,16 +347,16 @@ static MoreLinq.Extensions.SplitExtension.Split(this System.Co static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -363,10 +369,10 @@ static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(th static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! @@ -382,19 +388,19 @@ static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this Sys static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! @@ -417,10 +423,10 @@ static MoreLinq.MoreEnumerable.AggregateRight(thi static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! @@ -437,33 +443,33 @@ static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generi static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult @@ -486,28 +492,28 @@ static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnume static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -516,43 +522,43 @@ static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! sour static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult @@ -570,39 +576,39 @@ static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic. static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -616,16 +622,16 @@ static MoreLinq.MoreEnumerable.Split(this System.Collections.G static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -638,10 +644,10 @@ static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collection static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! @@ -657,19 +663,19 @@ static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! @@ -684,9 +690,3 @@ static MoreLinq.MoreEnumerable.ZipShortest(this System. static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt index cada4690e..6e1ad140c 100644 --- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt @@ -1,6 +1,6 @@ #nullable enable MoreLinq.Extensions.DuplicatesExtension -static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt index d13530e3e..2fae11b8f 100644 --- a/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt @@ -1,4 +1,10 @@ #nullable enable +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! MoreLinq.Experimental.Async.ExperimentalEnumerable MoreLinq.Experimental.AwaitQueryOptions MoreLinq.Experimental.AwaitQueryOptions.MaxConcurrency.get -> int? @@ -58,8 +64,8 @@ MoreLinq.Extensions.LastOrDefaultExtension MoreLinq.Extensions.LeadExtension MoreLinq.Extensions.LeftJoinExtension MoreLinq.Extensions.MaxByExtension -MoreLinq.Extensions.MinByExtension MoreLinq.Extensions.MaximaExtension +MoreLinq.Extensions.MinByExtension MoreLinq.Extensions.MinimaExtension MoreLinq.Extensions.MoveExtension MoreLinq.Extensions.OrderByExtension @@ -121,17 +127,17 @@ MoreLinq.OrderByDirection.Ascending = 0 -> MoreLinq.OrderByDirection MoreLinq.OrderByDirection.Descending = 1 -> MoreLinq.OrderByDirection MoreLinq.SequenceException MoreLinq.SequenceException.SequenceException() -> void -MoreLinq.SequenceException.SequenceException(string? message) -> void MoreLinq.SequenceException.SequenceException(string? message, System.Exception? innerException) -> void -static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.Collections.Generic.IAsyncEnumerable! +MoreLinq.SequenceException.SequenceException(string? message) -> void static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.Collections.Generic.IAsyncEnumerable! -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.Collections.Generic.IAsyncEnumerable! static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential(this MoreLinq.Experimental.IAwaitQuery! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! @@ -159,10 +165,10 @@ static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! @@ -179,35 +185,35 @@ static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collec static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult @@ -228,24 +234,24 @@ static MoreLinq.Extensions.FoldExtension.Fold(this System.Collection static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -254,43 +260,43 @@ static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerabl static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult @@ -305,22 +311,22 @@ static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Col static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! @@ -328,8 +334,8 @@ static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Col static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -343,16 +349,16 @@ static MoreLinq.Extensions.SplitExtension.Split(this System.Co static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -365,10 +371,10 @@ static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(th static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! @@ -384,19 +390,19 @@ static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this Sys static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! @@ -419,10 +425,10 @@ static MoreLinq.MoreEnumerable.AggregateRight(thi static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! @@ -439,35 +445,35 @@ static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generi static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult @@ -490,28 +496,28 @@ static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnume static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -520,43 +526,43 @@ static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! sour static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult @@ -574,39 +580,39 @@ static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic. static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -620,16 +626,16 @@ static MoreLinq.MoreEnumerable.Split(this System.Collections.G static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -642,10 +648,10 @@ static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collection static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! @@ -661,19 +667,19 @@ static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! @@ -688,9 +694,3 @@ static MoreLinq.MoreEnumerable.ZipShortest(this System. static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt index 980074ac0..45f09ae36 100644 --- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt @@ -1,4 +1,10 @@ #nullable enable +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! MoreLinq.Experimental.AwaitQueryOptions MoreLinq.Experimental.AwaitQueryOptions.MaxConcurrency.get -> int? MoreLinq.Experimental.AwaitQueryOptions.PreserveOrder.get -> bool @@ -55,8 +61,8 @@ MoreLinq.Extensions.LastOrDefaultExtension MoreLinq.Extensions.LeadExtension MoreLinq.Extensions.LeftJoinExtension MoreLinq.Extensions.MaxByExtension -MoreLinq.Extensions.MinByExtension MoreLinq.Extensions.MaximaExtension +MoreLinq.Extensions.MinByExtension MoreLinq.Extensions.MinimaExtension MoreLinq.Extensions.MoveExtension MoreLinq.Extensions.OrderByExtension @@ -118,16 +124,16 @@ MoreLinq.OrderByDirection.Ascending = 0 -> MoreLinq.OrderByDirection MoreLinq.OrderByDirection.Descending = 1 -> MoreLinq.OrderByDirection MoreLinq.SequenceException MoreLinq.SequenceException.SequenceException() -> void -MoreLinq.SequenceException.SequenceException(string? message) -> 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(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential(this MoreLinq.Experimental.IAwaitQuery! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! @@ -153,10 +159,10 @@ static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! @@ -173,33 +179,33 @@ static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collec static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult @@ -220,24 +226,24 @@ static MoreLinq.Extensions.FoldExtension.Fold(this System.Collection static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -246,43 +252,43 @@ static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerabl static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult @@ -297,22 +303,22 @@ static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Col static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! @@ -320,8 +326,8 @@ static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Col static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -335,16 +341,16 @@ static MoreLinq.Extensions.SplitExtension.Split(this System.Co static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -357,10 +363,10 @@ static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(th static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! @@ -376,19 +382,19 @@ static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this Sys static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! @@ -411,10 +417,10 @@ static MoreLinq.MoreEnumerable.AggregateRight(thi static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! @@ -431,33 +437,33 @@ static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generi static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult @@ -480,28 +486,28 @@ static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnume static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -510,43 +516,43 @@ static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! sour static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult @@ -564,39 +570,39 @@ static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic. static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.MoreEnumerable.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -610,16 +616,16 @@ static MoreLinq.MoreEnumerable.Split(this System.Collections.G static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -632,10 +638,10 @@ static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collection static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! @@ -651,19 +657,19 @@ static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! @@ -678,9 +684,3 @@ static MoreLinq.MoreEnumerable.ZipShortest(this System. static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt index cada4690e..6e1ad140c 100644 --- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt @@ -1,6 +1,6 @@ #nullable enable MoreLinq.Extensions.DuplicatesExtension -static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt index c0f90f6d2..ef2bcb5b6 100644 --- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt @@ -1,4 +1,10 @@ #nullable enable +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! MoreLinq.Experimental.Async.ExperimentalEnumerable MoreLinq.Experimental.AwaitQueryOptions MoreLinq.Experimental.AwaitQueryOptions.MaxConcurrency.get -> int? @@ -57,8 +63,8 @@ MoreLinq.Extensions.LastOrDefaultExtension MoreLinq.Extensions.LeadExtension MoreLinq.Extensions.LeftJoinExtension MoreLinq.Extensions.MaxByExtension -MoreLinq.Extensions.MinByExtension MoreLinq.Extensions.MaximaExtension +MoreLinq.Extensions.MinByExtension MoreLinq.Extensions.MinimaExtension MoreLinq.Extensions.MoveExtension MoreLinq.Extensions.OrderByExtension @@ -120,18 +126,18 @@ MoreLinq.OrderByDirection.Ascending = 0 -> MoreLinq.OrderByDirection MoreLinq.OrderByDirection.Descending = 1 -> MoreLinq.OrderByDirection MoreLinq.SequenceException MoreLinq.SequenceException.SequenceException() -> void -MoreLinq.SequenceException.SequenceException(string? message) -> 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.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.Collections.Generic.IAsyncEnumerable! static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.Collections.Generic.IAsyncEnumerable! -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.Collections.Generic.IAsyncEnumerable! static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential(this MoreLinq.Experimental.IAwaitQuery! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! @@ -159,10 +165,10 @@ static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! @@ -179,33 +185,33 @@ static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collec static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult @@ -226,24 +232,24 @@ static MoreLinq.Extensions.FoldExtension.Fold(this System.Collection static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -252,43 +258,43 @@ static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerabl static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult @@ -303,22 +309,22 @@ static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Col static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! @@ -326,8 +332,8 @@ static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Col static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -341,16 +347,16 @@ static MoreLinq.Extensions.SplitExtension.Split(this System.Co static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -363,10 +369,10 @@ static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(th static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! @@ -382,19 +388,19 @@ static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this Sys static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! @@ -417,10 +423,10 @@ static MoreLinq.MoreEnumerable.AggregateRight(thi static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! @@ -437,33 +443,33 @@ static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generi static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult @@ -486,28 +492,28 @@ static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnume static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -516,43 +522,43 @@ static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! sour static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult @@ -570,39 +576,39 @@ static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic. static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -616,16 +622,16 @@ static MoreLinq.MoreEnumerable.Split(this System.Collections.G static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! @@ -638,10 +644,10 @@ static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collection static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! @@ -657,19 +663,19 @@ static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! @@ -684,9 +690,3 @@ static MoreLinq.MoreEnumerable.ZipShortest(this System. static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt index cada4690e..6e1ad140c 100644 --- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt @@ -1,6 +1,6 @@ #nullable enable MoreLinq.Extensions.DuplicatesExtension -static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! From 6947b396e7ec9f94757154edbcda56f08c080297 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 16 Nov 2023 23:19:29 +0100 Subject: [PATCH 134/157] Add scripts to mark shipped API Derived from: - https://github.com/dotnet/roslyn/blob/494a8afcbf6df00df329de9f6a51c54514b1665f/scripts/PublicApi/mark-shipped.ps1 - https://github.com/dotnet/roslyn/blob/494a8afcbf6df00df329de9f6a51c54514b1665f/scripts/PublicApi/mark-shipped.cmd --- .config/dotnet-tools.json | 6 ++++++ tools/mark-shipped.cmd | 2 ++ tools/mark-shipped.ps1 | 44 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 52 insertions(+) create mode 100644 tools/mark-shipped.cmd create mode 100644 tools/mark-shipped.ps1 diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json index 87d6ac9db..a3de0d7a5 100644 --- a/.config/dotnet-tools.json +++ b/.config/dotnet-tools.json @@ -19,6 +19,12 @@ "commands": [ "meziantou.validate-nuget-package" ] + }, + "powershell": { + "version": "7.4.0", + "commands": [ + "pwsh" + ] } } } diff --git a/tools/mark-shipped.cmd b/tools/mark-shipped.cmd new file mode 100644 index 000000000..c3924cdf2 --- /dev/null +++ b/tools/mark-shipped.cmd @@ -0,0 +1,2 @@ +@echo off +dotnet pwsh -NoProfile -ExecutionPolicy RemoteSigned -File "%~dpn0.ps1" diff --git a/tools/mark-shipped.ps1 b/tools/mark-shipped.ps1 new file mode 100644 index 000000000..70d13cd5e --- /dev/null +++ b/tools/mark-shipped.ps1 @@ -0,0 +1,44 @@ +[CmdletBinding(PositionalBinding=$false)] +param () + +Set-StrictMode -Version 2.0 +$ErrorActionPreference = 'Stop' + +function MarkShipped([string]$dir) +{ + $shippedFilePath = Join-Path $dir 'PublicAPI.Shipped.txt' + [array]$shipped = Get-Content $shippedFilePath + + $unshippedFilePath = Join-Path $dir 'PublicAPI.Unshipped.txt' + [array]$unshipped = Get-Content $unshippedFilePath | ? { $_ -and $_ -notmatch '^#' } + + $removed = @() + $removedPrefix = '*REMOVED*'; + Write-Verbose "Processing $dir" + + foreach ($item in $unshipped) + { + if ($item.StartsWith($removedPrefix)) + { + $item = $item.Substring($removedPrefix.Length) + $removed += $item + } + else + { + $shipped += $item + } + } + + $shipped | + Sort-Object | + ? { -not $removed.Contains($_) } | + Out-File $shippedFilePath -Encoding Ascii + + '#nullable enable' | Out-File $unshippedFilePath -Encoding Ascii +} + +foreach ($file in Get-ChildItem -re -in 'PublicApi.Shipped.txt') +{ + $dir = Split-Path -parent $file + MarkShipped $dir +} From 4272b2b2198eb079e986d164383d246e8a207faf Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Fri, 24 Nov 2023 00:28:21 +0100 Subject: [PATCH 135/157] Update shipped API for v4.1 --- .../PublicAPI/net6.0/PublicAPI.Shipped.txt | 5 + .../PublicAPI/net6.0/PublicAPI.Unshipped.txt | 5 - .../PublicAPI/net8.0/PublicAPI.Shipped.txt | 695 ++++++++++++++++++ .../PublicAPI/net8.0/PublicAPI.Unshipped.txt | 695 ------------------ .../netstandard2.0/PublicAPI.Shipped.txt | 5 + .../netstandard2.0/PublicAPI.Unshipped.txt | 5 - .../netstandard2.1/PublicAPI.Shipped.txt | 5 + .../netstandard2.1/PublicAPI.Unshipped.txt | 5 - 8 files changed, 710 insertions(+), 710 deletions(-) diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt index 0b7808937..4b3290065 100644 --- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Shipped.txt @@ -36,6 +36,7 @@ MoreLinq.Extensions.CountBetweenExtension MoreLinq.Extensions.CountByExtension MoreLinq.Extensions.CountDownExtension MoreLinq.Extensions.DistinctByExtension +MoreLinq.Extensions.DuplicatesExtension MoreLinq.Extensions.EndsWithExtension MoreLinq.Extensions.EquiZipExtension MoreLinq.Extensions.EvaluateExtension @@ -190,6 +191,8 @@ static MoreLinq.Extensions.CountByExtension.CountBy(this System.C static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -448,6 +451,8 @@ static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Ge static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt index 6e1ad140c..7dc5c5811 100644 --- a/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/net6.0/PublicAPI.Unshipped.txt @@ -1,6 +1 @@ #nullable enable -MoreLinq.Extensions.DuplicatesExtension -static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt index 7dc5c5811..2fae11b8f 100644 --- a/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt +++ b/MoreLinq/PublicAPI/net8.0/PublicAPI.Shipped.txt @@ -1 +1,696 @@ #nullable enable +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +MoreLinq.Experimental.Async.ExperimentalEnumerable +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 +MoreLinq.Experimental.IAwaitQuery.Options.get -> MoreLinq.Experimental.AwaitQueryOptions! +MoreLinq.Experimental.IAwaitQuery.WithOptions(MoreLinq.Experimental.AwaitQueryOptions! options) -> MoreLinq.Experimental.IAwaitQuery! +MoreLinq.Experimental.ICurrentBuffer +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 +MoreLinq.IExtremaEnumerable.Take(int count) -> System.Collections.Generic.IEnumerable! +MoreLinq.IExtremaEnumerable.TakeLast(int count) -> System.Collections.Generic.IEnumerable! +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 +static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.Collections.Generic.IAsyncEnumerable! +static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.Collections.Generic.IAsyncEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential(this MoreLinq.Experimental.IAwaitQuery! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable!>! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator, System.Func!, TResult>! resultSelector) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Buffers.ArrayPool! pool, System.Func!, System.Collections.Generic.IEnumerable!>! bucketProjectionSelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Buffers.ArrayPool! pool, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency(this MoreLinq.Experimental.IAwaitQuery! source, int value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Memoize(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder(this MoreLinq.Experimental.IAwaitQuery! source, bool value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.Scheduler(this MoreLinq.Experimental.IAwaitQuery! source, System.Threading.Tasks.TaskScheduler! value) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many, System.Func! resultSelector) -> TResult +static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many) -> (TCardinality Cardinality, T? Value) +static MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! +static MoreLinq.Extensions.AcquireExtension.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SkipUntilExtension.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SliceExtension.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TakeUntilExtension.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.WindowRightExtension.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate +static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource +static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int +static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void +static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void +static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! +static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult +static MoreLinq.MoreEnumerable.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T +static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? +static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool +static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! +static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Unfold(TState state, System.Func! generator, System.Func! predicate, System.Func! stateSelector, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! +static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions! diff --git a/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt index 2fae11b8f..7dc5c5811 100644 --- a/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/net8.0/PublicAPI.Unshipped.txt @@ -1,696 +1 @@ #nullable enable -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.Extensions.FlattenExtension.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! selector) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -~static MoreLinq.MoreEnumerable.Flatten(this System.Collections.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -MoreLinq.Experimental.Async.ExperimentalEnumerable -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 -MoreLinq.Experimental.IAwaitQuery.Options.get -> MoreLinq.Experimental.AwaitQueryOptions! -MoreLinq.Experimental.IAwaitQuery.WithOptions(MoreLinq.Experimental.AwaitQueryOptions! options) -> MoreLinq.Experimental.IAwaitQuery! -MoreLinq.Experimental.ICurrentBuffer -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 -MoreLinq.IExtremaEnumerable.Take(int count) -> System.Collections.Generic.IEnumerable! -MoreLinq.IExtremaEnumerable.TakeLast(int count) -> System.Collections.Generic.IEnumerable! -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 -static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources, int maxConcurrent) -> System.Collections.Generic.IAsyncEnumerable! -static MoreLinq.Experimental.Async.ExperimentalEnumerable.Merge(this System.Collections.Generic.IEnumerable!>! sources) -> System.Collections.Generic.IAsyncEnumerable! -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, System.Func!, System.IObservable!>! accumulator1, System.Func!, System.IObservable!>! accumulator2, System.Func!, System.IObservable!>! accumulator3, System.Func!, System.IObservable!>! accumulator4, System.Func!, System.IObservable!>! accumulator5, System.Func!, System.IObservable!>! accumulator6, System.Func!, System.IObservable!>! accumulator7, System.Func!, System.IObservable!>! accumulator8, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.AsOrdered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.AsSequential(this MoreLinq.Experimental.IAwaitQuery! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Experimental.ExperimentalEnumerable.AsUnordered(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.Await(this System.Collections.Generic.IEnumerable!>! source) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.AwaitCompletion(this System.Collections.Generic.IEnumerable! source, System.Func!>! evaluator, System.Func!, TResult>! resultSelector) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Buffers.ArrayPool! pool, System.Func!, System.Collections.Generic.IEnumerable!>! bucketProjectionSelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Experimental.ExperimentalEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Buffers.ArrayPool! pool, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Experimental.ExperimentalEnumerable.MaxConcurrency(this MoreLinq.Experimental.IAwaitQuery! source, int value) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.Memoize(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Experimental.ExperimentalEnumerable.PreserveOrder(this MoreLinq.Experimental.IAwaitQuery! source, bool value) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.Scheduler(this MoreLinq.Experimental.IAwaitQuery! source, System.Threading.Tasks.TaskScheduler! value) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many, System.Func! resultSelector) -> TResult -static MoreLinq.Experimental.ExperimentalEnumerable.TrySingle(this System.Collections.Generic.IEnumerable! source, TCardinality zero, TCardinality one, TCardinality many) -> (TCardinality Cardinality, T? Value) -static MoreLinq.Experimental.ExperimentalEnumerable.UnboundedConcurrency(this MoreLinq.Experimental.IAwaitQuery! source) -> MoreLinq.Experimental.IAwaitQuery! -static MoreLinq.Extensions.AcquireExtension.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateExtension.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult -static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate -static MoreLinq.Extensions.AggregateRightExtension.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource -static MoreLinq.Extensions.AppendExtension.Append(this System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertCountExtension.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AssertExtension.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.AtLeastExtension.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.Extensions.AtMostExtension.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.Extensions.BacksertExtension.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.BatchExtension.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CartesianExtension.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ChooseExtension.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.CompareCountExtension.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int -static MoreLinq.Extensions.ConsumeExtension.Consume(this System.Collections.Generic.IEnumerable! source) -> void -static MoreLinq.Extensions.CountBetweenExtension.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.CountByExtension.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool -static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.EvaluateExtension.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ExactlyExtension.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ExceptByExtension.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ExcludeExtension.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FallbackIfEmptyExtension.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillBackwardExtension.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FillForwardExtension.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FirstExtension.First(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.Extensions.FirstOrDefaultExtension.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.FoldExtension.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.Extensions.ForEachExtension.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.Extensions.FullGroupJoinExtension.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.FullJoinExtension.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.GroupAdjacentExtension.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.IndexByExtension.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.IndexExtension.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.InsertExtension.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.InterleaveExtension.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LagExtension.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LastExtension.Last(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.Extensions.LastOrDefaultExtension.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeadExtension.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.LeftJoinExtension.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MaxByExtension.MaxBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MaximaExtension.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinByExtension.MinBy(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MinimaExtension.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.Extensions.MoveExtension.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.OrderByExtension.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.OrderedMergeExtension.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadExtension.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PadStartExtension.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PairwiseExtension.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortByExtension.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartialSortExtension.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PartitionExtension.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.Extensions.PermutationsExtension.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.PipeExtension.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PrependExtension.Prepend(this System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.PreScanExtension.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RandomSubsetExtension.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankByExtension.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RankExtension.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RepeatExtension.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RightJoinExtension.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.RunLengthEncodeExtension.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.ScanByExtension.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ScanExtension.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ScanRightExtension.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SegmentExtension.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ShuffleExtension.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SingleExtension.Single(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.Extensions.SingleOrDefaultExtension.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.Extensions.SkipLastExtension.SkipLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SkipUntilExtension.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SliceExtension.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SortedMergeExtension.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SplitExtension.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.Extensions.StartsWithExtension.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool -static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.SubsetsExtension.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.TagFirstLastExtension.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TakeEveryExtension.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TakeLastExtension.TakeLast(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TakeUntilExtension.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.ThenByExtension.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! -static MoreLinq.Extensions.ToArrayByIndexExtension.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! -static MoreLinq.Extensions.ToDataTableExtension.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDelimitedStringExtension.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToDictionaryExtension.ToDictionary(this System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.Extensions.ToHashSetExtension.ToHashSet(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.Extensions.ToLookupExtension.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! -static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TraceExtension.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.TransposeExtension.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.WindowExtension.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.WindowLeftExtension.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.WindowRightExtension.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipLongestExtension.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.ZipShortestExtension.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Acquire(this System.Collections.Generic.IEnumerable! source) -> TSource[]! -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, TAccumulate8 seed8, System.Func! accumulator8, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, TAccumulate7 seed7, System.Func! accumulator7, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, TAccumulate6 seed6, System.Func! accumulator6, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, TAccumulate5 seed5, System.Func! accumulator5, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, TAccumulate4 seed4, System.Func! accumulator4, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, TAccumulate3 seed3, System.Func! accumulator3, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Aggregate(this System.Collections.Generic.IEnumerable! source, TAccumulate1 seed1, System.Func! accumulator1, TAccumulate2 seed2, System.Func! accumulator2, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func, System.Func! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> TAccumulate -static MoreLinq.MoreEnumerable.AggregateRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> TSource -static MoreLinq.MoreEnumerable.Append(System.Collections.Generic.IEnumerable! head, T tail) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func? errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Assert(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count, System.Func! errorSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.AssertCount(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.AtLeast(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.MoreEnumerable.AtMost(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.MoreEnumerable.Backsert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Batch(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Collections.Generic.IEnumerable! eighth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Collections.Generic.IEnumerable! seventh, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Collections.Generic.IEnumerable! sixth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Collections.Generic.IEnumerable! fifth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Cartesian(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Choose(this System.Collections.Generic.IEnumerable! source, System.Func! chooser) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.CompareCount(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> int -static MoreLinq.MoreEnumerable.Consume(this System.Collections.Generic.IEnumerable! source) -> void -static MoreLinq.MoreEnumerable.CountBetween(this System.Collections.Generic.IEnumerable! source, int min, int max) -> bool -static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.DistinctBy(System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool -static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Evaluate(this System.Collections.Generic.IEnumerable!>! functions) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Exactly(this System.Collections.Generic.IEnumerable! source, int count) -> bool -static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? keyComparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ExceptBy(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Exclude(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, params T[]! fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEnumerable! fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3, T fallback4) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2, T fallback3) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FallbackIfEmpty(this System.Collections.Generic.IEnumerable! source, T fallback1, T fallback2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillBackward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func! fillSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FillForward(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.First(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.MoreEnumerable.FirstOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.Fold(this System.Collections.Generic.IEnumerable! source, System.Func! folder) -> TResult -static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.MoreEnumerable.ForEach(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> void -static MoreLinq.MoreEnumerable.From(params System.Func![]! functions) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.From(System.Func! function) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2, System.Func! function3) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.From(System.Func! function1, System.Func! function2) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.MoreEnumerable.FullGroupJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector) -> System.Collections.Generic.IEnumerable<(TKey Key, System.Collections.Generic.IEnumerable! First, System.Collections.Generic.IEnumerable! Second)>! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.FullJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Generate(TResult initial, System.Func! generator) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GenerateByIndex(System.Func! generator) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.GroupAdjacent(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source, int startIndex) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.Index(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.IndexBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.Insert(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, int index) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Interleave(this System.Collections.Generic.IEnumerable! sequence, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Lag(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLagValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Last(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.MoreEnumerable.LastOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Lead(this System.Collections.Generic.IEnumerable! source, int offset, TSource defaultLeadValue, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.LeftJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MaxBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Maxima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.MinBy(System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector, System.Collections.Generic.IComparer? comparer) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Minima(this System.Collections.Generic.IEnumerable! source, System.Func! selector) -> MoreLinq.IExtremaEnumerable! -static MoreLinq.MoreEnumerable.Move(this System.Collections.Generic.IEnumerable! source, int fromIndex, int count, int toIndex) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.OrderBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.OrderedMerge(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! firstSelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pad(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, System.Func! paddingSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width, TSource padding) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PadStart(this System.Collections.Generic.IEnumerable! source, int width) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Pairwise(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSort(this System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PartialSortBy(this System.Collections.Generic.IEnumerable! source, int count, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate, System.Func!, System.Collections.Generic.IEnumerable!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> (System.Collections.Generic.IEnumerable! True, System.Collections.Generic.IEnumerable! False) -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key, System.Func!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Collections.Generic.IEqualityComparer? comparer, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Partition(this System.Collections.Generic.IEnumerable!>! source, TKey key1, TKey key2, TKey key3, System.Func!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!, System.Collections.Generic.IEnumerable!>!, TResult>! resultSelector) -> TResult -static MoreLinq.MoreEnumerable.Permutations(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Pipe(this System.Collections.Generic.IEnumerable! source, System.Action! action) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Prepend(System.Collections.Generic.IEnumerable! source, TSource value) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.PreScan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation, TSource identity) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random() -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(System.Random! rand, int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(System.Random! rand, int minValue, int maxValue) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Random(System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomDouble() -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomDouble(System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RandomSubset(this System.Collections.Generic.IEnumerable! source, int subsetSize) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Rank(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RankBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Repeat(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Return(T item) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! firstKeySelector, System.Func! secondKeySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RightJoin(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! keySelector, System.Func! secondSelector, System.Func! bothSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.RunLengthEncode(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, TState seed, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Scan(this System.Collections.Generic.IEnumerable! source, System.Func! transformation) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.ScanBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Func! seedSelector, System.Func! accumulator) -> System.Collections.Generic.IEnumerable>! -static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, TAccumulate seed, System.Func! func) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ScanRight(this System.Collections.Generic.IEnumerable! source, System.Func! func) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Segment(this System.Collections.Generic.IEnumerable! source, System.Func! newSegmentPredicate) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Sequence(int start, int stop, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Sequence(int start, int stop) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source, System.Random! rand) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Shuffle(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Single(this MoreLinq.IExtremaEnumerable! source) -> T -static MoreLinq.MoreEnumerable.SingleOrDefault(this MoreLinq.IExtremaEnumerable! source) -> T? -static MoreLinq.MoreEnumerable.SkipLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.SkipUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Slice(this System.Collections.Generic.IEnumerable! sequence, int startIndex, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.SortedMerge(this System.Collections.Generic.IEnumerable! source, MoreLinq.OrderByDirection direction, System.Collections.Generic.IComparer? comparer, params System.Collections.Generic.IEnumerable![]! otherSequences) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer! comparer, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Func!, TResult>! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, System.Func! separatorFunc) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer, int count) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Split(this System.Collections.Generic.IEnumerable! source, TSource separator) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool -static MoreLinq.MoreEnumerable.StartsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool -static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence, int subsetSize) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.Subsets(this System.Collections.Generic.IEnumerable! sequence) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.TagFirstLast(this System.Collections.Generic.IEnumerable! source, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TakeEvery(this System.Collections.Generic.IEnumerable! source, int step) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TakeLast(System.Collections.Generic.IEnumerable! source, int count) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TakeUntil(this System.Collections.Generic.IEnumerable! source, System.Func! predicate) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.ThenBy(this System.Linq.IOrderedEnumerable! source, System.Func! keySelector, System.Collections.Generic.IComparer? comparer, MoreLinq.OrderByDirection direction) -> System.Linq.IOrderedEnumerable! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector, System.Func! resultSelector) -> TResult[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, int length, System.Func! indexSelector) -> T[]! -static MoreLinq.MoreEnumerable.ToArrayByIndex(this System.Collections.Generic.IEnumerable! source, System.Func! indexSelector) -> T[]! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table, params System.Linq.Expressions.Expression!>![]! expressions) -> TTable! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, TTable! table) -> TTable! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source, params System.Linq.Expressions.Expression!>![]! expressions) -> System.Data.DataTable! -static MoreLinq.MoreEnumerable.ToDataTable(this System.Collections.Generic.IEnumerable! source) -> System.Data.DataTable! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDelimitedString(this System.Collections.Generic.IEnumerable! source, string! delimiter) -> string! -static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToDictionary(System.Collections.Generic.IEnumerable>! source) -> System.Collections.Generic.Dictionary! -static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToHashSet(System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.HashSet! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable<(TKey Key, TValue Value)>! source) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.ToLookup(this System.Collections.Generic.IEnumerable>! source) -> System.Linq.ILookup! -static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, string? format) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source, System.Func! formatter) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Trace(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Transpose(this System.Collections.Generic.IEnumerable!>! source) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.TraverseBreadthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.TraverseDepthFirst(T root, System.Func!>! childrenSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Unfold(TState state, System.Func! generator, System.Func! predicate, System.Func! stateSelector, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Window(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.WindowLeft(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.WindowRight(this System.Collections.Generic.IEnumerable! source, int size) -> System.Collections.Generic.IEnumerable!>! -static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipLongest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.ZipShortest(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! -static readonly MoreLinq.Experimental.AwaitQueryOptions.Default -> MoreLinq.Experimental.AwaitQueryOptions! diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt index 45f09ae36..d485d1b09 100644 --- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Shipped.txt @@ -34,6 +34,7 @@ MoreLinq.Extensions.CountBetweenExtension MoreLinq.Extensions.CountByExtension MoreLinq.Extensions.CountDownExtension MoreLinq.Extensions.DistinctByExtension +MoreLinq.Extensions.DuplicatesExtension MoreLinq.Extensions.EndsWithExtension MoreLinq.Extensions.EquiZipExtension MoreLinq.Extensions.EvaluateExtension @@ -184,6 +185,8 @@ static MoreLinq.Extensions.CountByExtension.CountBy(this System.C static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -442,6 +445,8 @@ static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Ge static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt index 6e1ad140c..7dc5c5811 100644 --- a/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt @@ -1,6 +1 @@ #nullable enable -MoreLinq.Extensions.DuplicatesExtension -static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt index ef2bcb5b6..578da10e2 100644 --- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt @@ -36,6 +36,7 @@ MoreLinq.Extensions.CountBetweenExtension MoreLinq.Extensions.CountByExtension MoreLinq.Extensions.CountDownExtension MoreLinq.Extensions.DistinctByExtension +MoreLinq.Extensions.DuplicatesExtension MoreLinq.Extensions.EndsWithExtension MoreLinq.Extensions.EquiZipExtension MoreLinq.Extensions.EvaluateExtension @@ -190,6 +191,8 @@ static MoreLinq.Extensions.CountByExtension.CountBy(this System.C static MoreLinq.Extensions.CountDownExtension.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.DistinctByExtension.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool static MoreLinq.Extensions.EndsWithExtension.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.Extensions.EquiZipExtension.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! @@ -448,6 +451,8 @@ static MoreLinq.MoreEnumerable.CountBy(this System.Collections.Ge static MoreLinq.MoreEnumerable.CountDown(this System.Collections.Generic.IEnumerable! source, int count, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.DistinctBy(this System.Collections.Generic.IEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! +static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEqualityComparer? comparer) -> bool static MoreLinq.MoreEnumerable.EndsWith(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second) -> bool static MoreLinq.MoreEnumerable.EquiZip(this System.Collections.Generic.IEnumerable! first, System.Collections.Generic.IEnumerable! second, System.Collections.Generic.IEnumerable! third, System.Collections.Generic.IEnumerable! fourth, System.Func! resultSelector) -> System.Collections.Generic.IEnumerable! diff --git a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt index 6e1ad140c..7dc5c5811 100644 --- a/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt +++ b/MoreLinq/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt @@ -1,6 +1 @@ #nullable enable -MoreLinq.Extensions.DuplicatesExtension -static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.Extensions.DuplicatesExtension.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source, System.Collections.Generic.IEqualityComparer? comparer) -> System.Collections.Generic.IEnumerable! -static MoreLinq.MoreEnumerable.Duplicates(this System.Collections.Generic.IEnumerable! source) -> System.Collections.Generic.IEnumerable! From 0e154ef592f33ce0f6f3d534a9eedee273f0ce72 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 26 Nov 2023 17:31:55 +0100 Subject: [PATCH 136/157] Refactor "Permutations" into an iterator method --- MoreLinq.Test/PermutationsTest.cs | 9 +- MoreLinq/Extensions.g.cs | 1 - MoreLinq/NestedLoops.cs | 52 ------- MoreLinq/Permutations.cs | 243 +++++++++++------------------- 4 files changed, 94 insertions(+), 211 deletions(-) delete mode 100644 MoreLinq/NestedLoops.cs diff --git a/MoreLinq.Test/PermutationsTest.cs b/MoreLinq.Test/PermutationsTest.cs index 6941bc778..6a99681a2 100644 --- a/MoreLinq.Test/PermutationsTest.cs +++ b/MoreLinq.Test/PermutationsTest.cs @@ -184,7 +184,14 @@ public void TestPermutationsAreIndependent() var permutedSets = set.Permutations(); var listPermutations = new List>(); - listPermutations.AddRange(permutedSets); + foreach (var ps in permutedSets) + { + Assert.That(ps, Is.Not.All.Negative); + listPermutations.Add(ps); + for (var i = 0; i < ps.Count; i++) + ps[i] = -1; + } + Assert.That(listPermutations, Is.Not.Empty); for (var i = 0; i < listPermutations.Count; i++) diff --git a/MoreLinq/Extensions.g.cs b/MoreLinq/Extensions.g.cs index 83b2e90ac..81e42062e 100644 --- a/MoreLinq/Extensions.g.cs +++ b/MoreLinq/Extensions.g.cs @@ -4644,7 +4644,6 @@ public static TResult Partition(this IEnumerable /// Generates a sequence of lists that represent the permutations of the original sequence. /// diff --git a/MoreLinq/NestedLoops.cs b/MoreLinq/NestedLoops.cs deleted file mode 100644 index 587b368e0..000000000 --- a/MoreLinq/NestedLoops.cs +++ /dev/null @@ -1,52 +0,0 @@ -#region License and Terms -// MoreLINQ - Extensions to LINQ to Objects -// Copyright (c) 2010 Leopold Bushkin. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -#endregion - -namespace MoreLinq -{ - using System; - using System.Collections.Generic; - using System.Linq; - - public static partial class MoreEnumerable - { - // This extension method was developed (primarily) to support the - // implementation of the Permutations() extension methods. - - /// - /// Produces a sequence from an action based on the dynamic generation of N nested loops - /// whose iteration counts are defined by a sequence of loop counts. - /// - /// Action delegate for which to produce a nested loop sequence - /// A sequence of loop repetition counts - /// A sequence of Action representing the expansion of a set of nested loops - - static IEnumerable NestedLoops(this Action action, IEnumerable loopCounts) - { - if (action == null) throw new ArgumentNullException(nameof(action)); - if (loopCounts == null) throw new ArgumentNullException(nameof(loopCounts)); - - return _(); IEnumerable _() - { - var count = loopCounts.DefaultIfEmpty() - .Aggregate((acc, x) => checked(acc * x)); - - for (var i = 0UL; i < count; i++) - yield return action; - } - } - } -} diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs index 3bd52ec81..2324750bb 100644 --- a/MoreLinq/Permutations.cs +++ b/MoreLinq/Permutations.cs @@ -18,165 +18,11 @@ namespace MoreLinq { using System; - using System.Collections; using System.Collections.Generic; - using System.Diagnostics.CodeAnalysis; using System.Linq; public static partial class MoreEnumerable { - /// - /// The private implementation class that produces permutations of a sequence. - /// - - sealed class PermutationEnumerator : IEnumerator> - { - // NOTE: The algorithm used to generate permutations uses the fact that any set - // can be put into 1-to-1 correspondence with the set of ordinals number (0..n). - // The implementation here is based on the algorithm described by Kenneth H. Rosen, - // in Discrete Mathematics and Its Applications, 2nd edition, pp. 282-284. - // - // There are two significant changes from the original implementation. - // First, the algorithm uses lazy evaluation and streaming to fit well into the - // nature of most LINQ evaluations. - // - // Second, the algorithm has been modified to use dynamically generated nested loop - // state machines, rather than an integral computation of the factorial function - // to determine when to terminate. The original algorithm required a priori knowledge - // of the number of iterations necessary to produce all permutations. This is a - // necessary step to avoid overflowing the range of the permutation arrays used. - // The number of permutation iterations is defined as the factorial of the original - // set size minus 1. - // - // However, there's a fly in the ointment. The factorial function grows VERY rapidly. - // 13! overflows the range of a Int32; while 28! overflows the range of decimal. - // To overcome these limitations, the algorithm relies on the fact that the factorial - // of N is equivalent to the evaluation of N-1 nested loops. Unfortunately, you can't - // just code up a variable number of nested loops ... this is where .NET generators - // with their elegant 'yield return' syntax come to the rescue. - // - // The methods of the Loop extension class (For and NestedLoops) provide the implementation - // of dynamic nested loops using generators and sequence composition. In a nutshell, - // the two Repeat() functions are the constructor of loops and nested loops, respectively. - // The NestedLoops() function produces a composition of loops where the loop counter - // for each nesting level is defined in a separate sequence passed in the call. - // - // For example: NestedLoops( () => DoSomething(), new[] { 6, 8 } ) - // - // is equivalent to: for( int i = 0; i < 6; i++ ) - // for( int j = 0; j < 8; j++ ) - // DoSomething(); - - readonly IList valueSet; - readonly int[] permutation; - readonly IEnumerable generator; - - IEnumerator generatorIterator; - bool hasMoreResults; - - IList? current; - - public PermutationEnumerator(IEnumerable valueSet) - { - this.valueSet = valueSet.ToArray(); - this.permutation = new int[this.valueSet.Count]; - // The nested loop construction below takes into account the fact that: - // 1) for empty sets and sets of cardinality 1, there exists only a single permutation. - // 2) for sets larger than 1 element, the number of nested loops needed is: set.Count-1 - this.generator = NestedLoops(NextPermutation, Generate(2UL, n => n + 1).Take(Math.Max(0, this.valueSet.Count - 1))); - Reset(); - } - - [MemberNotNull(nameof(generatorIterator))] - public void Reset() - { - this.current = null; - this.generatorIterator?.Dispose(); - // restore lexographic ordering of the permutation indexes - for (var i = 0; i < this.permutation.Length; i++) - this.permutation[i] = i; - // start a new iteration over the nested loop generator - this.generatorIterator = this.generator.GetEnumerator(); - // we must advance the nested loop iterator to the initial element, - // this ensures that we only ever produce N!-1 calls to NextPermutation() - _ = this.generatorIterator.MoveNext(); - this.hasMoreResults = true; // there's always at least one permutation: the original set itself - } - - public IList Current - { - get - { - Debug.Assert(this.current is not null); - return this.current; - } - } - - object IEnumerator.Current => Current; - - public bool MoveNext() - { - this.current = PermuteValueSet(); - // check if more permutation left to enumerate - var prevResult = this.hasMoreResults; - this.hasMoreResults = this.generatorIterator.MoveNext(); - if (this.hasMoreResults) - this.generatorIterator.Current(); // produce the next permutation ordering - // we return prevResult rather than m_HasMoreResults because there is always - // at least one permutation: the original set. Also, this provides a simple way - // to deal with the disparity between sets that have only one loop level (size 0-2) - // and those that have two or more (size > 2). - return prevResult; - } - - void IDisposable.Dispose() => this.generatorIterator.Dispose(); - - /// - /// Transposes elements in the cached permutation array to produce the next permutation - /// - void NextPermutation() - { - // find the largest index j with m_Permutation[j] < m_Permutation[j+1] - var j = this.permutation.Length - 2; - while (this.permutation[j] > this.permutation[j + 1]) - j--; - - // find index k such that m_Permutation[k] is the smallest integer - // greater than m_Permutation[j] to the right of m_Permutation[j] - var k = this.permutation.Length - 1; - while (this.permutation[j] > this.permutation[k]) - k--; - - (this.permutation[j], this.permutation[k]) = (this.permutation[k], this.permutation[j]); - - // move the tail of the permutation after the jth position in increasing order - for (int x = this.permutation.Length - 1, y = j + 1; x > y; x--, y++) - (this.permutation[x], this.permutation[y]) = (this.permutation[y], this.permutation[x]); - } - - /// - /// Creates a new list containing the values from the original - /// set in their new permuted order. - /// - /// - /// The reason we return a new permuted value set, rather than reuse - /// an existing collection, is that we have no control over what the - /// consumer will do with the results produced. They could very easily - /// generate and store a set of permutations and only then begin to - /// process them. If we reused the same collection, the caller would - /// be surprised to discover that all of the permutations looked the - /// same. - /// - /// Array of permuted source sequence values - T[] PermuteValueSet() - { - var permutedSet = new T[this.permutation.Length]; - for (var i = 0; i < this.permutation.Length; i++) - permutedSet[i] = this.valueSet[this.permutation[i]]; - return permutedSet; - } - } - /// /// Generates a sequence of lists that represent the permutations of the original sequence. /// @@ -205,10 +51,93 @@ public static IEnumerable> Permutations(this IEnumerable sequence return _(); IEnumerable> _() { - using var iter = new PermutationEnumerator(sequence); + // The algorithm used to generate permutations uses the fact that any set can be put + // into 1-to-1 correspondence with the set of ordinals number (0..n). The + // implementation here is based on the algorithm described by Kenneth H. Rosen, in + // Discrete Mathematics and Its Applications, 2nd edition, pp. 282-284. + + var valueSet = sequence.ToArray(); + + // There's always at least one permutation: a copy of original set. + + yield return (IList)valueSet.Clone(); + + // For empty sets and sets of cardinality 1, there exists only a single permutation. + + if (valueSet.Length is 0 or 1) + yield break; + + var permutation = new int[valueSet.Length]; + + // Initialize lexographic ordering of the permutation indexes. + + for (var i = 0; i < permutation.Length; i++) + permutation[i] = i; + + // For sets larger than 1 element, the number of nested loops needed is one less + // than the set length. Note that the factorial grows VERY rapidly such that 13! + // overflows the range of an Int32 and 28! overflows the range of a Decimal. + + ulong factorial = valueSet.Length switch + { + 0 => 1, + 1 => 1, + 2 => 2, + 3 => 6, + 4 => 24, + 5 => 120, + 6 => 720, + 7 => 5_040, + 8 => 40_320, + 9 => 362_880, + 10 => 3_628_800, + 11 => 39_916_800, + 12 => 479_001_600, + 13 => 6_227_020_800, + 14 => 87_178_291_200, + 15 => 1_307_674_368_000, + 16 => 20_922_789_888_000, + 17 => 355_687_428_096_000, + 18 => 6_402_373_705_728_000, + 19 => 121_645_100_408_832_000, + 20 => 2_432_902_008_176_640_000, + _ => throw new OverflowException("Too many permutations."), + }; + + for (var n = 1UL; n < factorial; n++) + { + // Transposes elements in the cached permutation array to produce the next + // permutation. + + // Find the largest index j with permutation[j] < permutation[j+1]: + + var j = permutation.Length - 2; + while (permutation[j] > permutation[j + 1]) + j--; + + // Find index k such that permutation[k] is the smallest integer greater than + // permutation[j] to the right of permutation[j]: + + var k = permutation.Length - 1; + while (permutation[j] > permutation[k]) + k--; - while (iter.MoveNext()) - yield return iter.Current; + (permutation[j], permutation[k]) = (permutation[k], permutation[j]); + + // Move the tail of the permutation after the j-th position in increasing order. + + for (int x = permutation.Length - 1, y = j + 1; x > y; x--, y++) + (permutation[x], permutation[y]) = (permutation[y], permutation[x]); + + // Yield a new array containing the values from the original set in their new + // permuted order. + + var permutedSet = new T[permutation.Length]; + for (var i = 0; i < permutation.Length; i++) + permutedSet[i] = valueSet[permutation[i]]; + + yield return permutedSet; + } } } } From 7424fa24c8655e8a7e9562a4a5c3d5a7379b797b Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 30 Nov 2023 18:32:48 +0100 Subject: [PATCH 137/157] Prepare for 4.2 --- MoreLinq/MoreLinq.csproj | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 38d48eee5..d21855c5e 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -119,7 +119,7 @@ $([System.Text.RegularExpressions.Regex]::Replace($(Copyright), `\s+`, ` `).Trim()) MoreLINQ en-US - 4.1.0 + 4.2.0 MoreLINQ Developers. netstandard2.0;netstandard2.1;net6.0;net8.0 portable @@ -136,7 +136,7 @@ ..\dist README.md true - 4.0.0 + 4.1.0 true true true From ab184db01e6b38b34ba3cff6a2b8683f8326bcbb Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 30 Nov 2023 18:37:40 +0100 Subject: [PATCH 138/157] Remove extra blank lines in "ToDataTable" tests --- MoreLinq.Test/ToDataTableTest.cs | 3 --- 1 file changed, 3 deletions(-) diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs index 9b4249d62..e13bbdada 100644 --- a/MoreLinq.Test/ToDataTableTest.cs +++ b/MoreLinq.Test/ToDataTableTest.cs @@ -41,10 +41,8 @@ sealed class TestObject(int key) public override string ToString() => nameof(TestObject); } - readonly IReadOnlyCollection testObjects; - public ToDataTableTest() => this.testObjects = Enumerable.Range(0, 3) .Select(i => new TestObject(i)) @@ -174,7 +172,6 @@ public void ToDataTableWithSchema() readonly struct Point { - #pragma warning disable CA1805 // Do not initialize unnecessarily (avoids CS0649) public static Point Empty = new(); #pragma warning restore CA1805 // Do not initialize unnecessarily From c4cd0519b538ec0a221598ce0266e243c86aace0 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 30 Nov 2023 18:38:50 +0100 Subject: [PATCH 139/157] Use primary constructor for test "Point" --- MoreLinq.Test/ToDataTableTest.cs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs index e13bbdada..d6cac4cda 100644 --- a/MoreLinq.Test/ToDataTableTest.cs +++ b/MoreLinq.Test/ToDataTableTest.cs @@ -170,15 +170,14 @@ public void ToDataTableWithSchema() Assert.That(rows.Select(r => r["Value"]).ToArray(), Is.EqualTo(vars.Select(e => e.Value).ToArray())); } - readonly struct Point + readonly struct Point(int x, int y) { #pragma warning disable CA1805 // Do not initialize unnecessarily (avoids CS0649) public static Point Empty = new(); #pragma warning restore CA1805 // Do not initialize unnecessarily public bool IsEmpty => X == 0 && Y == 0; - public int X { get; } - public int Y { get; } - public Point(int x, int y) : this() { X = x; Y = y; } + public int X { get; } = x; + public int Y { get; } = y; } [Test] From 47a14cb22091f464b582e083a6842bc4ef6589f4 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 30 Nov 2023 18:40:22 +0100 Subject: [PATCH 140/157] Use object pattern to get value in tests --- MoreLinq.Test/SequenceTest.cs | 5 +++-- MoreLinq.Test/TraceTest.cs | 4 ++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/MoreLinq.Test/SequenceTest.cs b/MoreLinq.Test/SequenceTest.cs index ad01a274d..4c75ff43f 100644 --- a/MoreLinq.Test/SequenceTest.cs +++ b/MoreLinq.Test/SequenceTest.cs @@ -110,8 +110,9 @@ public void SequenceWithDescendingRangeDescendigStep(int start, int stop, int st [TestCase(int.MinValue, int.MinValue, null)] public void SequenceWithStartEqualsStop(int start, int stop, int? step) { - var result = step.HasValue ? MoreEnumerable.Sequence(start, stop, step.Value) - : MoreEnumerable.Sequence(start, stop); + var result = step is { } someStep + ? MoreEnumerable.Sequence(start, stop, someStep) + : MoreEnumerable.Sequence(start, stop); Assert.That(start, Is.EqualTo(result.Single())); } diff --git a/MoreLinq.Test/TraceTest.cs b/MoreLinq.Test/TraceTest.cs index 6e32ba55e..e0604a2cb 100644 --- a/MoreLinq.Test/TraceTest.cs +++ b/MoreLinq.Test/TraceTest.cs @@ -67,8 +67,8 @@ public void TraceSequenceWithFormatter() var trace = Lines(CaptureTrace(delegate { var formatter = CultureInfo.InvariantCulture; - new int?[] { 1234, null, 5678 }.Trace(n => n.HasValue - ? n.Value.ToString("N0", formatter) + new int?[] { 1234, null, 5678 }.Trace(n => n is { } some + ? some.ToString("N0", formatter) : "#NULL") .Consume(); })); From 00fbb7e23b202a6646277b1f16cbd84f3c00b10e Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 20 Jan 2024 17:07:44 +0100 Subject: [PATCH 141/157] Add GitHub Action workflow for building --- .github/workflows/build.yml | 121 ++++++++++++++++++++++++++++++++++++ .gitignore | 1 + appveyor.yml | 3 + 3 files changed, 125 insertions(+) create mode 100644 .github/workflows/build.yml diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 000000000..105aa1427 --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,121 @@ +name: Build + +on: + push: + paths-ignore: + - '*.md' + - '*.txt' + branches: + - master + pull_request: + types: [opened, reopened, synchronize] + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +env: + DOTNET_CLI_TELEMETRY_OPTOUT: true + DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true + SKIP_TEST_BUILD: true + +jobs: + build: + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [windows-2022, ubuntu-22.04, macos-11] + + steps: + + - name: Checkout + uses: actions/checkout@v3 + + - name: Setup Node + uses: actions/setup-node@v3 + with: + node-version: '14' + + - name: Install ECLint + run: npm install -g eclint + + - name: Delete EditorConfig file + run: git rm .editorconfig + + - name: Check Final New-Line + run: eclint check -n "**/*.{cs,tt,cmd,sh,md,txt,yml}" + + - name: Check Trailing Whitespace + run: eclint check -w "**/*.{cs,tt,cmd,sh,md,txt,yml,json,sln,csproj,shfbproj}" + + - name: Restore Checkout + run: git reset --hard + + - name: Setup .NET SDK per "global.json" + uses: actions/setup-dotnet@v3 + with: + global-json-file: global.json + + - name: Setup .NET SDK 7.0 + uses: actions/setup-dotnet@v3 + with: + dotnet-version: 7.0.x + + - name: Setup .NET SDK 6.0 + uses: actions/setup-dotnet@v3 + with: + dotnet-version: 6.0.x + + - name: .NET Information + run: dotnet --info + + - name: Check Unit Tests Never Import "System.Linq" + shell: pwsh + run: | + grep --extended-regexp '^[[:space:]]*using[[:space:]]+System\.Linq;' (dir -Recurse -File -Filter *Test.cs MoreLinq.Test) + if ($LASTEXITCODE -eq 0) { + throw 'Unit tests should not import System.Linq' + } else { + $LASTEXITCODE = 0 + } + + - name: Build & Pack (Windows) + shell: cmd + if: runner.os == 'Windows' + run: call pack.cmd + + - name: Build & Pack (Linux/macOS) + if: runner.os != 'Windows' + run: ./pack.sh + + - name: Check Uncommitted Changes + shell: pwsh + run: | + $diff = git diff --ignore-all-space --exit-code 2>&1 + $diff | % { if ($_ -is [string]) { $_ } else { [string]$_ } } | echo + if ($LASTEXITCODE -ne 0) { + throw "New code was generated during build that's not been committed." + } + + - name: Validate NuGet Packages + shell: pwsh + run: | + dir dist\*.nupkg | % { + dotnet meziantou.validate-nuget-package --excluded-rules IconMustBeSet $_ + if ($LASTEXITCODE) { + throw "Package validation failed: $_" + } + } + + - name: Test (Windows) + shell: cmd + if: runner.os == 'Windows' + run: call test.cmd + + - name: Test (Linux/macOS) + if: runner.os != 'Windows' + run: ./test.sh + + - name: Publish Coverage to Codecov + uses: codecov/codecov-action@v3 diff --git a/.gitignore b/.gitignore index 68976a434..0ea80d0b7 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,6 @@ *.opencover.xml **/TestResults/ +.actrc ### VisualStudio ### ## Ignore Visual Studio temporary files, build results, and diff --git a/appveyor.yml b/appveyor.yml index 98a25c24b..407dd2f0a 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -7,6 +7,9 @@ environment: DOTNET_CLI_TELEMETRY_OPTOUT: true DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true SKIP_TEST_BUILD: true +skip_commits: + files: + - .github/** for: - matrix: From 48279d039fa99b136c804adf65c676f7521797cc Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 20 Jan 2024 17:08:13 +0100 Subject: [PATCH 142/157] Update Ubuntu image on CI to use 18.04 --- appveyor.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/appveyor.yml b/appveyor.yml index 407dd2f0a..c7f50f424 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -1,7 +1,7 @@ version: '{build}' image: - Visual Studio 2022 -- Ubuntu1604 +- Ubuntu1804 - macos-bigsur environment: DOTNET_CLI_TELEMETRY_OPTOUT: true @@ -35,9 +35,9 @@ for: - matrix: only: - - image: Ubuntu1604 + - image: Ubuntu1804 environment: - IMAGE_NAME: ubuntu-16.04 + IMAGE_NAME: ubuntu-18.04 - matrix: only: From 60390e8d9825b86c68982ebae3cd30c1549cdec3 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 20 Jan 2024 17:10:45 +0100 Subject: [PATCH 143/157] Ignore CI build on GitHub on AppVeyor changes --- .github/workflows/build.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 105aa1427..f51ded59d 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -5,6 +5,7 @@ on: paths-ignore: - '*.md' - '*.txt' + - appveyor.yml branches: - master pull_request: From 5bf0bbcd4277a852be5f6974c7dd5ca4973f7c6b Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Fri, 19 Jan 2024 18:56:14 +0100 Subject: [PATCH 144/157] Fix pending tasks wait loop in (async) "Merge" --- MoreLinq/Experimental/Async/Merge.cs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/MoreLinq/Experimental/Async/Merge.cs b/MoreLinq/Experimental/Async/Merge.cs index 72c9a459c..f414eaa7d 100644 --- a/MoreLinq/Experimental/Async/Merge.cs +++ b/MoreLinq/Experimental/Async/Merge.cs @@ -201,13 +201,14 @@ async IAsyncEnumerable Async([EnumeratorCancellation]CancellationToken cancel // is in some defined state before disposing it otherwise it could throw // "NotSupportedException". - if (pendingTaskList is { Count: > 0 }) + if (pendingTaskList is { Count: > 0 } somePendingTaskList) { - while (await Task.WhenAny(pendingTaskList) - .ConfigureAwait(false) is { } completedTask) + do { - _ = pendingTaskList.Remove(completedTask); + var completedTask = await Task.WhenAny(somePendingTaskList).ConfigureAwait(false); + _ = somePendingTaskList.Remove(completedTask); } + while (somePendingTaskList.Count > 0); } foreach (var enumerator in enumeratorList) From 7ccea7acb5e8b317af91a5148a3550ee45810599 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 1 Apr 2024 15:34:32 +0200 Subject: [PATCH 145/157] Fix style errors: IDE0028, IDE0290, IDE0300 & IDE0301 - bld\ExtensionsGenerator\Program.cs(394,15,394,35): error IDE0290: Use primary constructor - bld\ExtensionsGenerator\Program.cs(386,81,386,86): error IDE0301: Collection initialization can be simplified - bld\ExtensionsGenerator\Program.cs(362,15,362,22): error IDE0290: Use primary constructor - MoreLinq\FullGroupJoin.cs(165,67,165,72): error IDE0301: Collection initialization can be simplified - MoreLinq\Maxima.cs(243,37,243,42): error IDE0301: Collection initialization can be simplified - MoreLinq\Maxima.cs(293,89,293,94): error IDE0301: Collection initialization can be simplified - MoreLinq\Maxima.cs(323,28,323,31): error IDE0028: Collection initialization can be simplified - MoreLinq\Maxima.cs(235,37,235,42): error IDE0301: Collection initialization can be simplified - MoreLinq\Partition.cs(356,28,356,33): error IDE0301: Collection initialization can be simplified - MoreLinq\Partition.cs(357,28,357,33): error IDE0301: Collection initialization can be simplified - MoreLinq\Partition.cs(358,28,358,33): error IDE0301: Collection initialization can be simplified - MoreLinq\TakeLast.cs(57,43,57,48): error IDE0301: Collection initialization can be simplified - MoreLinq.Test\TestExtensions.cs(41,69,41,72): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\TestExtensions.cs(36,67,36,70): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\TestExtensions.cs(36,67,36,72): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\TestExtensions.cs(41,69,41,74): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\TestExtensions.cs(47,63,47,66): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\TestExtensions.cs(47,63,47,68): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\SampleData.cs(33,71,33,74): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\SampleData.cs(33,71,33,76): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\SampleData.cs(28,75,28,78): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\SampleData.cs(28,75,28,80): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\AggregateTest.cs(100,57,100,60): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\AggregateTest.cs(100,57,100,69): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\BacksertTest.cs(35,64,35,67): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\BacksertTest.cs(35,64,35,69): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\EndsWithTest.cs(55,45,55,48): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\EndsWithTest.cs(55,45,55,55): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\EndsWithTest.cs(61,45,61,48): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\EndsWithTest.cs(61,45,61,50): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\CountDownTest.cs(157,27,157,35): error IDE0290: Use primary constructor - MoreLinq.Test\Enumerable.cs(148,28,148,33): error IDE0301: Collection initialization can be simplified - MoreLinq.Test\InsertTest.cs(28,62,28,65): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\InsertTest.cs(28,62,28,67): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\Scope.cs(26,19,26,24): error IDE0290: Use primary constructor - MoreLinq.Test\ReturnTest.cs(151,53,151,56): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\ReturnTest.cs(151,53,151,65): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\StartsWithTest.cs(55,47,55,50): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\StartsWithTest.cs(55,47,55,57): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\StartsWithTest.cs(61,47,61,50): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\StartsWithTest.cs(61,47,61,52): error IDE0300: Collection initialization can be simplified - MoreLinq.Test\TraverseTest.cs(41,111,41,116): error IDE0301: Collection initialization can be simplified - MoreLinq.Test\TraverseTest.cs(49,113,49,118): error IDE0301: Collection initialization can be simplified See also: - IDE0028: Use primary constructor https://learn.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/ide0028 - IDE0290: Use primary constructor https://learn.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/ide0290 - IDE0300: Collection initialization can be simplified https://learn.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/ide0300 - IDE0301: Collection initialization can be simplified https://learn.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/ide0301 --- MoreLinq.Test/AggregateTest.cs | 4 +++- MoreLinq.Test/BacksertTest.cs | 2 +- MoreLinq.Test/CountDownTest.cs | 7 ++----- MoreLinq.Test/EndsWithTest.cs | 4 ++-- MoreLinq.Test/Enumerable.cs | 2 ++ MoreLinq.Test/InsertTest.cs | 2 +- MoreLinq.Test/ReturnTest.cs | 4 +++- MoreLinq.Test/SampleData.cs | 12 ++++-------- MoreLinq.Test/Scope.cs | 7 ++----- MoreLinq.Test/StartsWithTest.cs | 4 ++-- MoreLinq.Test/TestExtensions.cs | 17 +++++++---------- MoreLinq.Test/TraverseTest.cs | 4 ++-- MoreLinq/FullGroupJoin.cs | 3 +-- MoreLinq/Maxima.cs | 8 ++++---- MoreLinq/Partition.cs | 7 +------ MoreLinq/TakeLast.cs | 2 +- bld/ExtensionsGenerator/Program.cs | 15 +++++---------- 17 files changed, 43 insertions(+), 61 deletions(-) diff --git a/MoreLinq.Test/AggregateTest.cs b/MoreLinq.Test/AggregateTest.cs index 04ec29154..bd2bafe7c 100644 --- a/MoreLinq.Test/AggregateTest.cs +++ b/MoreLinq.Test/AggregateTest.cs @@ -97,7 +97,9 @@ from pair in pairs into t select new TestCaseData(t.Method, t.Args).SetName(t.Name).Returns(t.Expectation); - [TestCaseSource(nameof(AccumulatorsTestSource), new object[] { nameof(Accumulators), 10 })] +#pragma warning disable NUnit1018 // Parameter count does not match (false negative) + [TestCaseSource(nameof(AccumulatorsTestSource), [nameof(Accumulators), 10])] +#pragma warning restore NUnit1018 // Parameter count does not match public object? Accumulators(MethodInfo method, object[] args) => method.Invoke(null, args); diff --git a/MoreLinq.Test/BacksertTest.cs b/MoreLinq.Test/BacksertTest.cs index dbc985903..1a093754f 100644 --- a/MoreLinq.Test/BacksertTest.cs +++ b/MoreLinq.Test/BacksertTest.cs @@ -32,7 +32,7 @@ public void BacksertIsLazy() [Test] public void BacksertWithNegativeIndex() { - Assert.That(() => Enumerable.Range(1, 10).Backsert(new[] { 97, 98, 99 }, -1), + Assert.That(() => Enumerable.Range(1, 10).Backsert([97, 98, 99], -1), Throws.ArgumentOutOfRangeException("index")); } diff --git a/MoreLinq.Test/CountDownTest.cs b/MoreLinq.Test/CountDownTest.cs index e852a3e0c..06b0b8434 100644 --- a/MoreLinq.Test/CountDownTest.cs +++ b/MoreLinq.Test/CountDownTest.cs @@ -150,12 +150,9 @@ public static IReadOnlyCollection /// for another. /// - abstract class Sequence : IEnumerable + abstract class Sequence(Func, IEnumerator>? em) : IEnumerable { - readonly Func, IEnumerator> em; - - protected Sequence(Func, IEnumerator>? em) => - this.em = em ?? (e => e); + readonly Func, IEnumerator> em = em ?? (e => e); public IEnumerator GetEnumerator() => this.em(Items.GetEnumerator()); diff --git a/MoreLinq.Test/EndsWithTest.cs b/MoreLinq.Test/EndsWithTest.cs index 11add633c..9ebce0a62 100644 --- a/MoreLinq.Test/EndsWithTest.cs +++ b/MoreLinq.Test/EndsWithTest.cs @@ -52,13 +52,13 @@ public bool EndsWithWithStrings(string first, string second) [Test] public void EndsWithReturnsTrueIfBothEmpty() { - Assert.That(new int[0].EndsWith(new int[0]), Is.True); + Assert.That(new int[0].EndsWith([]), Is.True); } [Test] public void EndsWithReturnsFalseIfOnlyFirstIsEmpty() { - Assert.That(new int[0].EndsWith(new[] { 1, 2, 3 }), Is.False); + Assert.That(new int[0].EndsWith([1, 2, 3]), Is.False); } [TestCase("", "", ExpectedResult = true)] diff --git a/MoreLinq.Test/Enumerable.cs b/MoreLinq.Test/Enumerable.cs index f7795af4e..a63220274 100644 --- a/MoreLinq.Test/Enumerable.cs +++ b/MoreLinq.Test/Enumerable.cs @@ -145,7 +145,9 @@ public static TSource ElementAt(this IEnumerable source, int i LinqEnumerable.ElementAtOrDefault(source, index); public static IEnumerable Empty() => +#pragma warning disable IDE0301 // Simplify collection initialization LinqEnumerable.Empty(); +#pragma warning restore IDE0301 // Simplify collection initialization public static IEnumerable Except(this IEnumerable first, IEnumerable second) => LinqEnumerable.Except(first, second); diff --git a/MoreLinq.Test/InsertTest.cs b/MoreLinq.Test/InsertTest.cs index 1dd148bd0..b7cb97ede 100644 --- a/MoreLinq.Test/InsertTest.cs +++ b/MoreLinq.Test/InsertTest.cs @@ -25,7 +25,7 @@ public class InsertTest [Test] public void InsertWithNegativeIndex() { - Assert.That(() => Enumerable.Range(1, 10).Insert(new[] { 97, 98, 99 }, -1), + Assert.That(() => Enumerable.Range(1, 10).Insert([97, 98, 99], -1), Throws.ArgumentOutOfRangeException("index")); } diff --git a/MoreLinq.Test/ReturnTest.cs b/MoreLinq.Test/ReturnTest.cs index 769d7168d..cf8494047 100644 --- a/MoreLinq.Test/ReturnTest.cs +++ b/MoreLinq.Test/ReturnTest.cs @@ -148,7 +148,9 @@ static IEnumerable UnsupportedActions(string testName) => } select new TestCaseData(ma.Action).SetName($"{testName}({ma.MethodName})"); - [TestCaseSource(nameof(UnsupportedActions), new object[] { nameof(TestUnsupportedMethodShouldThrow) })] +#pragma warning disable NUnit1018 // Parameter count does not match (false negative) + [TestCaseSource(nameof(UnsupportedActions), [nameof(TestUnsupportedMethodShouldThrow)])] +#pragma warning restore NUnit1018 // Parameter count does not match public void TestUnsupportedMethodShouldThrow(Action unsupportedAction) { Assert.That(() => unsupportedAction(), Throws.InstanceOf()); diff --git a/MoreLinq.Test/SampleData.cs b/MoreLinq.Test/SampleData.cs index 6e257d060..a7861226d 100644 --- a/MoreLinq.Test/SampleData.cs +++ b/MoreLinq.Test/SampleData.cs @@ -25,15 +25,11 @@ namespace MoreLinq.Test /// static class SampleData { - internal static readonly ReadOnlyCollection Strings = new(new[] - { - "ax", "hello", "world", "aa", "ab", "ay", "az" - }); + internal static readonly ReadOnlyCollection + Strings = new(["ax", "hello", "world", "aa", "ab", "ay", "az"]); - internal static readonly ReadOnlyCollection Values = new(new[] - { - 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 - }); + internal static readonly ReadOnlyCollection + Values = new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); internal static readonly Func Plus = (a, b) => a + b; internal static readonly Func Mul = (a, b) => a * b; diff --git a/MoreLinq.Test/Scope.cs b/MoreLinq.Test/Scope.cs index b770bc14f..9d847681f 100644 --- a/MoreLinq.Test/Scope.cs +++ b/MoreLinq.Test/Scope.cs @@ -19,12 +19,9 @@ namespace MoreLinq.Test { using System; - abstract class Scope : IDisposable + abstract class Scope(T current) : IDisposable { - readonly T old; - - protected Scope(T current) => this.old = current; - public virtual void Dispose() => Restore(this.old); + public virtual void Dispose() => Restore(current); protected abstract void Restore(T old); } } diff --git a/MoreLinq.Test/StartsWithTest.cs b/MoreLinq.Test/StartsWithTest.cs index cb4148b52..a252072d1 100644 --- a/MoreLinq.Test/StartsWithTest.cs +++ b/MoreLinq.Test/StartsWithTest.cs @@ -52,13 +52,13 @@ public bool StartsWithWithStrings(string first, string second) [Test] public void StartsWithReturnsTrueIfBothEmpty() { - Assert.That(new int[0].StartsWith(new int[0]), Is.True); + Assert.That(new int[0].StartsWith([]), Is.True); } [Test] public void StartsWithReturnsFalseIfOnlyFirstIsEmpty() { - Assert.That(new int[0].StartsWith(new[] { 1, 2, 3 }), Is.False); + Assert.That(new int[0].StartsWith([1, 2, 3]), Is.False); } [TestCase("", "", ExpectedResult = true)] diff --git a/MoreLinq.Test/TestExtensions.cs b/MoreLinq.Test/TestExtensions.cs index 706641f1b..76d6869c6 100644 --- a/MoreLinq.Test/TestExtensions.cs +++ b/MoreLinq.Test/TestExtensions.cs @@ -33,22 +33,19 @@ public enum SourceKind static class SourceKinds { - public static readonly IEnumerable Sequence = new[] - { - SourceKind.Sequence, - }; + public static readonly IEnumerable Sequence = [ + SourceKind.Sequence + ]; - public static readonly IEnumerable Collection = new[] - { + public static readonly IEnumerable Collection = [ SourceKind.BreakingCollection, SourceKind.BreakingReadOnlyCollection - }; + ]; - public static readonly IEnumerable List = new[] - { + public static readonly IEnumerable List = [ SourceKind.BreakingList, SourceKind.BreakingReadOnlyList - }; + ]; } static partial class TestExtensions diff --git a/MoreLinq.Test/TraverseTest.cs b/MoreLinq.Test/TraverseTest.cs index 89a0b2277..7a02f264f 100644 --- a/MoreLinq.Test/TraverseTest.cs +++ b/MoreLinq.Test/TraverseTest.cs @@ -38,7 +38,7 @@ public void TraverseBreadthFirstIsStreaming() [Test] public void TraverseDepthFirstPreservesChildrenOrder() { - var res = MoreEnumerable.TraverseDepthFirst(0, i => i == 0 ? Enumerable.Range(1, 10) : Enumerable.Empty()); + var res = MoreEnumerable.TraverseDepthFirst(0, i => i == 0 ? Enumerable.Range(1, 10) : []); res.AssertSequenceEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10); } @@ -46,7 +46,7 @@ public void TraverseDepthFirstPreservesChildrenOrder() [Test] public void TraverseBreadthFirstPreservesChildrenOrder() { - var res = MoreEnumerable.TraverseBreadthFirst(0, i => i == 0 ? Enumerable.Range(1, 10) : Enumerable.Empty()); + var res = MoreEnumerable.TraverseBreadthFirst(0, i => i == 0 ? Enumerable.Range(1, 10) : []); res.AssertSequenceEqual(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10); } diff --git a/MoreLinq/FullGroupJoin.cs b/MoreLinq/FullGroupJoin.cs index 7ce9b687f..2f6fb56c8 100644 --- a/MoreLinq/FullGroupJoin.cs +++ b/MoreLinq/FullGroupJoin.cs @@ -19,7 +19,6 @@ namespace MoreLinq { using System; using System.Collections.Generic; - using System.Linq; // Inspiration & credit: http://stackoverflow.com/a/13503860/6682 static partial class MoreEnumerable @@ -162,7 +161,7 @@ IEnumerable _(IEqualityComparer comparer) if (alookup.Contains(b.Key)) continue; // We can skip the lookup because we are iterating over keys not found in the first sequence - yield return resultSelector(b.Key, Enumerable.Empty(), b); + yield return resultSelector(b.Key, [], b); } } } diff --git a/MoreLinq/Maxima.cs b/MoreLinq/Maxima.cs index 5292dbcf8..645ea374d 100644 --- a/MoreLinq/Maxima.cs +++ b/MoreLinq/Maxima.cs @@ -232,7 +232,7 @@ IEnumerator IEnumerable.GetEnumerator() => public IEnumerable Take(int count) => count switch { - 0 => Enumerable.Empty(), + 0 => [], 1 => ExtremaBy(source, Extremum.First, 1 , selector, comparer), _ => ExtremaBy(source, Extrema.First , count, selector, comparer) }; @@ -240,7 +240,7 @@ public IEnumerable Take(int count) => public IEnumerable TakeLast(int count) => count switch { - 0 => Enumerable.Empty(), + 0 => [], 1 => ExtremaBy(source, Extremum.Last, 1 , selector, comparer), _ => ExtremaBy(source, Extrema.Last , count, selector, comparer) }; @@ -290,7 +290,7 @@ sealed class Extremum : Extrema<(bool, T), T> public override void Restart(ref (bool, T) store) => store = default; public override IEnumerable GetEnumerable((bool, T) store) => - store is (true, var item) ? Enumerable.Repeat(item, 1) : Enumerable.Empty(); + store is (true, var item) ? [item] : []; public override void Add(ref (bool, T) store, int? limit, T item) { @@ -320,7 +320,7 @@ IEnumerable Extrema() using var e = source.GetEnumerator(); if (!e.MoveNext()) - return new List(); + return []; var store = extrema.New(); extrema.Add(ref store, limit, e.Current); diff --git a/MoreLinq/Partition.cs b/MoreLinq/Partition.cs index 9660186fc..5c99b997f 100644 --- a/MoreLinq/Partition.cs +++ b/MoreLinq/Partition.cs @@ -351,12 +351,7 @@ static TResult PartitionImpl(IEnumerable>? etc = null; - var groups = new[] - { - Enumerable.Empty(), - Enumerable.Empty(), - Enumerable.Empty(), - }; + var groups = new IEnumerable[] { [], [], [] }; foreach (var e in source) { diff --git a/MoreLinq/TakeLast.cs b/MoreLinq/TakeLast.cs index 88eac7a8e..c20d40f47 100644 --- a/MoreLinq/TakeLast.cs +++ b/MoreLinq/TakeLast.cs @@ -54,7 +54,7 @@ public static IEnumerable TakeLast(this IEnumerable s { if (source == null) throw new ArgumentNullException(nameof(source)); - return count < 1 ? Enumerable.Empty() + return count < 1 ? [] : source.CountDown(count, (e, cd) => (Element: e, Countdown: cd)) .SkipWhile(e => e.Countdown == null) .Select(e => e.Element); diff --git a/bld/ExtensionsGenerator/Program.cs b/bld/ExtensionsGenerator/Program.cs index 35dae759d..ec466df30 100644 --- a/bld/ExtensionsGenerator/Program.cs +++ b/bld/ExtensionsGenerator/Program.cs @@ -357,11 +357,9 @@ select Walk(te.Type))), // - Each type parameter (recursively) // -abstract class TypeKey : IComparable +abstract class TypeKey(string name) : IComparable { - protected TypeKey(string name) => Name = name; - - public string Name { get; } + public string Name { get; } = name; public abstract ImmutableList Parameters { get; } public virtual int CompareTo(TypeKey? other) @@ -383,18 +381,15 @@ protected static int Compare(IEnumerable a, IEnumerable b) => sealed class SimpleTypeKey(string name) : TypeKey(name) { public override string ToString() => Name; - public override ImmutableList Parameters => ImmutableList.Empty; + public override ImmutableList Parameters => []; } -abstract class ParameterizedTypeKey : TypeKey +abstract class ParameterizedTypeKey(string name, ImmutableList parameters) : TypeKey(name) { protected ParameterizedTypeKey(string name, TypeKey parameter) : this(name, [parameter]) { } - protected ParameterizedTypeKey(string name, ImmutableList parameters) : - base(name) => Parameters = parameters; - - public override ImmutableList Parameters { get; } + public override ImmutableList Parameters { get; } = parameters; } sealed class GenericTypeKey(string name, ImmutableList parameters) : From 9e8073d8b502fbc91697d3cdb25b97a23d71a6c4 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 1 Apr 2024 15:57:06 +0200 Subject: [PATCH 146/157] Update packages to their latest versions --- MoreLinq.Test/Async/TestingAsyncSequence.cs | 2 +- MoreLinq.Test/MoreLinq.Test.csproj | 12 ++++++------ MoreLinq/MoreLinq.csproj | 4 ++-- .../MoreLinq.ExtensionsGenerator.csproj | 2 +- 4 files changed, 10 insertions(+), 10 deletions(-) diff --git a/MoreLinq.Test/Async/TestingAsyncSequence.cs b/MoreLinq.Test/Async/TestingAsyncSequence.cs index af234111c..af1012b5f 100644 --- a/MoreLinq.Test/Async/TestingAsyncSequence.cs +++ b/MoreLinq.Test/Async/TestingAsyncSequence.cs @@ -67,7 +67,7 @@ void AssertDisposed() if (this.disposed is null) return; - Assert.IsTrue(this.disposed, "Expected sequence to be disposed."); + Assert.That(this.disposed, Is.True, "Expected sequence to be disposed."); this.disposed = null; } diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index 0b6d42855..413e5e7f4 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -17,7 +17,7 @@ - + runtime; build; native; contentfiles; analyzers; buildtransitive all @@ -26,20 +26,20 @@ runtime; build; native; contentfiles; analyzers all - - + + all runtime; build; native; contentfiles; analyzers; buildtransitive - - + + all runtime; build; native; contentfiles; analyzers; buildtransitive - + diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index d21855c5e..6c1c604b5 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -161,8 +161,8 @@ runtime; build; native; contentfiles; analyzers all - - + + diff --git a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj index 39132fd4d..a8c8964b0 100644 --- a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj +++ b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj @@ -6,7 +6,7 @@ - + From 017e47757893d9168c78ae374a22016650871bd5 Mon Sep 17 00:00:00 2001 From: JacobSilasBentley <30935918+JacobSilasBentley@users.noreply.github.com> Date: Wed, 1 May 2024 19:21:48 +0700 Subject: [PATCH 147/157] Use static iterator methods to avoid closure This is a squashed merge of PR #1064 that: - closes #906 - fixes #1065 --------- Co-authored-by: Atif Aziz --- MoreLinq.Test/RankTest.cs | 2 +- MoreLinq/Assert.cs | 4 +- MoreLinq/AssertCount.cs | 4 +- MoreLinq/Backsert.cs | 4 +- MoreLinq/Batch.cs | 4 +- MoreLinq/Cartesian.g.cs | 70 +++++++++++++++++++++++++--- MoreLinq/Cartesian.g.tt | 9 +++- MoreLinq/Choose.cs | 6 ++- MoreLinq/CountBy.cs | 4 +- MoreLinq/CountDown.cs | 21 ++++++--- MoreLinq/DistinctBy.cs | 7 ++- MoreLinq/EndsWith.cs | 8 ++-- MoreLinq/ExceptBy.cs | 8 +++- MoreLinq/Exclude.cs | 4 +- MoreLinq/Experimental/Async/Merge.cs | 4 +- MoreLinq/Experimental/Await.cs | 13 +++++- MoreLinq/Experimental/Batch.cs | 7 ++- MoreLinq/FallbackIfEmpty.cs | 11 ++++- MoreLinq/Flatten.cs | 14 ++++-- MoreLinq/From.cs | 12 +++-- MoreLinq/FullGroupJoin.cs | 10 +++- MoreLinq/FullJoin.cs | 12 ++++- MoreLinq/Generate.cs | 4 +- MoreLinq/Insert.cs | 4 +- MoreLinq/Lag.cs | 8 +++- MoreLinq/Lead.cs | 8 +++- MoreLinq/Maxima.cs | 7 ++- MoreLinq/Move.cs | 6 +-- MoreLinq/OrderedMerge.cs | 19 +++++++- MoreLinq/PadStart.cs | 8 +++- MoreLinq/Pairwise.cs | 4 +- MoreLinq/Permutations.cs | 4 +- MoreLinq/Pipe.cs | 4 +- MoreLinq/PreScan.cs | 7 ++- MoreLinq/Rank.cs | 4 +- MoreLinq/RunLengthEncode.cs | 4 +- MoreLinq/ScanBy.cs | 9 +++- MoreLinq/Segment.cs | 4 +- MoreLinq/SkipUntil.cs | 4 +- MoreLinq/Slice.cs | 6 +-- MoreLinq/SortedMerge.cs | 4 +- MoreLinq/Split.cs | 8 +++- MoreLinq/Subsets.cs | 8 +++- MoreLinq/TagFirstLast.cs | 4 +- MoreLinq/TakeUntil.cs | 4 +- MoreLinq/Transpose.cs | 4 +- MoreLinq/Traverse.cs | 8 +++- MoreLinq/Unfold.cs | 9 +++- MoreLinq/Window.cs | 4 +- MoreLinq/WindowLeft.cs | 4 +- MoreLinq/WindowRight.cs | 6 ++- 51 files changed, 326 insertions(+), 89 deletions(-) diff --git a/MoreLinq.Test/RankTest.cs b/MoreLinq.Test/RankTest.cs index ad36c7afb..6e84dc719 100644 --- a/MoreLinq.Test/RankTest.cs +++ b/MoreLinq.Test/RankTest.cs @@ -124,7 +124,7 @@ public void TestRankGroupedItems() .Concat(Enumerable.Range(0, count)) .Concat(Enumerable.Range(0, count)); using var ts = sequence.AsTestingSequence(); - var result = ts.Rank(); + var result = ts.Rank().ToArray(); Assert.That(result.Distinct().Count(), Is.EqualTo(count)); Assert.That(result, Is.EqualTo(sequence.Reverse().Select(x => x + 1))); diff --git a/MoreLinq/Assert.cs b/MoreLinq/Assert.cs index 1b272d8ed..0836113a6 100644 --- a/MoreLinq/Assert.cs +++ b/MoreLinq/Assert.cs @@ -65,7 +65,9 @@ public static IEnumerable Assert(this IEnumerable sou if (source == null) throw new ArgumentNullException(nameof(source)); if (predicate == null) throw new ArgumentNullException(nameof(predicate)); - return _(); IEnumerable _() + return _(source, predicate, errorSelector); + + static IEnumerable _(IEnumerable source, Func predicate, Func? errorSelector) { foreach (var element in source) { diff --git a/MoreLinq/AssertCount.cs b/MoreLinq/AssertCount.cs index 14a55c1a4..f742f36c7 100644 --- a/MoreLinq/AssertCount.cs +++ b/MoreLinq/AssertCount.cs @@ -70,7 +70,9 @@ public static IEnumerable AssertCount(this IEnumerable _() + return _(source, count, errorSelector); + + static IEnumerable _(IEnumerable source, int count, Func errorSelector) { if (source.TryAsCollectionLike() is { Count: var collectionCount } && collectionCount.CompareTo(count) is var comparison && comparison != 0) diff --git a/MoreLinq/Backsert.cs b/MoreLinq/Backsert.cs index 490e7702e..47407bf83 100644 --- a/MoreLinq/Backsert.cs +++ b/MoreLinq/Backsert.cs @@ -65,10 +65,10 @@ public static IEnumerable Backsert(this IEnumerable first, IEnumerable< { < 0 => throw new ArgumentOutOfRangeException(nameof(index), "Index cannot be negative."), 0 => first.Concat(second), - _ => _() + _ => _(first, second, index) }; - IEnumerable _() + static IEnumerable _(IEnumerable first, IEnumerable second, int index) { using var e = first.CountDown(index, ValueTuple.Create).GetEnumerator(); diff --git a/MoreLinq/Batch.cs b/MoreLinq/Batch.cs index 5da60c07a..3d30e4f1f 100644 --- a/MoreLinq/Batch.cs +++ b/MoreLinq/Batch.cs @@ -86,7 +86,9 @@ public static IEnumerable Batch(this IEnumerable _() + return _(source, size, resultSelector); + + static IEnumerable _(IEnumerable source, int size, Func resultSelector) { switch (source) { diff --git a/MoreLinq/Cartesian.g.cs b/MoreLinq/Cartesian.g.cs index 64694c065..74740706c 100644 --- a/MoreLinq/Cartesian.g.cs +++ b/MoreLinq/Cartesian.g.cs @@ -69,7 +69,12 @@ public static IEnumerable Cartesian( if (second == null) throw new ArgumentNullException(nameof(second)); if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return _(); IEnumerable _() + return _(first, second, resultSelector); + + static IEnumerable _( + IEnumerable first, + IEnumerable second, + Func resultSelector) { IEnumerable secondMemo; @@ -123,7 +128,13 @@ public static IEnumerable Cartesian( if (third == null) throw new ArgumentNullException(nameof(third)); if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return _(); IEnumerable _() + return _(first, second, third, resultSelector); + + static IEnumerable _( + IEnumerable first, + IEnumerable second, + IEnumerable third, + Func resultSelector) { IEnumerable secondMemo; IEnumerable thirdMemo; @@ -185,7 +196,14 @@ public static IEnumerable Cartesian( if (fourth == null) throw new ArgumentNullException(nameof(fourth)); if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return _(); IEnumerable _() + return _(first, second, third, fourth, resultSelector); + + static IEnumerable _( + IEnumerable first, + IEnumerable second, + IEnumerable third, + IEnumerable fourth, + Func resultSelector) { IEnumerable secondMemo; IEnumerable thirdMemo; @@ -255,7 +273,15 @@ public static IEnumerable Cartesian( if (fifth == null) throw new ArgumentNullException(nameof(fifth)); if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return _(); IEnumerable _() + return _(first, second, third, fourth, fifth, resultSelector); + + static IEnumerable _( + IEnumerable first, + IEnumerable second, + IEnumerable third, + IEnumerable fourth, + IEnumerable fifth, + Func resultSelector) { IEnumerable secondMemo; IEnumerable thirdMemo; @@ -333,7 +359,16 @@ public static IEnumerable Cartesian( if (sixth == null) throw new ArgumentNullException(nameof(sixth)); if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return _(); IEnumerable _() + return _(first, second, third, fourth, fifth, sixth, resultSelector); + + static IEnumerable _( + IEnumerable first, + IEnumerable second, + IEnumerable third, + IEnumerable fourth, + IEnumerable fifth, + IEnumerable sixth, + Func resultSelector) { IEnumerable secondMemo; IEnumerable thirdMemo; @@ -419,7 +454,17 @@ public static IEnumerable Cartesian _() + return _(first, second, third, fourth, fifth, sixth, seventh, resultSelector); + + static IEnumerable _( + IEnumerable first, + IEnumerable second, + IEnumerable third, + IEnumerable fourth, + IEnumerable fifth, + IEnumerable sixth, + IEnumerable seventh, + Func resultSelector) { IEnumerable secondMemo; IEnumerable thirdMemo; @@ -513,7 +558,18 @@ public static IEnumerable Cartesian _() + return _(first, second, third, fourth, fifth, sixth, seventh, eighth, resultSelector); + + static IEnumerable _( + IEnumerable first, + IEnumerable second, + IEnumerable third, + IEnumerable fourth, + IEnumerable fifth, + IEnumerable sixth, + IEnumerable seventh, + IEnumerable eighth, + Func resultSelector) { IEnumerable secondMemo; IEnumerable thirdMemo; diff --git a/MoreLinq/Cartesian.g.tt b/MoreLinq/Cartesian.g.tt index 4bc112cea..4c078b9bc 100644 --- a/MoreLinq/Cartesian.g.tt +++ b/MoreLinq/Cartesian.g.tt @@ -115,7 +115,14 @@ Func<<#= string.Join(", ", from x in o.Arguments select "T" + x.Number) #>, TRes <# } #> if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return _(); IEnumerable _() + return _(<#= string.Join(", ", from x in o.Arguments select x.Ordinal) #>, resultSelector); + + static IEnumerable _( + <# foreach (var arg in o.Arguments) { #> +IEnumerable> <#= arg.Ordinal #>, + <# + } #> +Func<<#= string.Join(", ", from x in o.Arguments select "T" + x.Number) #>, TResult> resultSelector) { <# foreach (var arg in o.Arguments.Skip(1)) { #> IEnumerable> <#= arg.Ordinal #>Memo; diff --git a/MoreLinq/Choose.cs b/MoreLinq/Choose.cs index bffbc72d9..865fb3928 100644 --- a/MoreLinq/Choose.cs +++ b/MoreLinq/Choose.cs @@ -55,7 +55,11 @@ public static IEnumerable Choose(this IEnumerable source if (source == null) throw new ArgumentNullException(nameof(source)); if (chooser == null) throw new ArgumentNullException(nameof(chooser)); - return _(); IEnumerable _() + return _(source, chooser); + + static IEnumerable _( + IEnumerable source, + Func chooser) { foreach (var item in source) { diff --git a/MoreLinq/CountBy.cs b/MoreLinq/CountBy.cs index c1f8873ed..0ea540d81 100644 --- a/MoreLinq/CountBy.cs +++ b/MoreLinq/CountBy.cs @@ -55,7 +55,9 @@ public static IEnumerable> CountBy(this I if (source == null) throw new ArgumentNullException(nameof(source)); if (keySelector == null) throw new ArgumentNullException(nameof(keySelector)); - return _(); IEnumerable> _() + return _(source, keySelector, comparer); + + static IEnumerable> _(IEnumerable source, Func keySelector, IEqualityComparer? comparer) { List keys; List counts; diff --git a/MoreLinq/CountDown.cs b/MoreLinq/CountDown.cs index 53310e79a..aa0da23ce 100644 --- a/MoreLinq/CountDown.cs +++ b/MoreLinq/CountDown.cs @@ -58,12 +58,15 @@ public static IEnumerable CountDown(this IEnumerable sou if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); return source.TryAsListLike() is { } listLike - ? IterateList(listLike) + ? IterateList(listLike, count, resultSelector) : source.TryAsCollectionLike() is { } collectionLike - ? IterateCollection(collectionLike) - : IterateSequence(); + ? IterateCollection(collectionLike, count, resultSelector) + : IterateSequence(source, count, resultSelector); - IEnumerable IterateList(ListLike list) + static IEnumerable IterateList( + ListLike list, + int count, + Func resultSelector) { var listCount = list.Count; var countdown = Math.Min(count, listCount); @@ -72,14 +75,20 @@ IEnumerable IterateList(ListLike list) yield return resultSelector(list[i], listCount - i <= count ? --countdown : null); } - IEnumerable IterateCollection(CollectionLike collection) + static IEnumerable IterateCollection( + CollectionLike collection, + int count, + Func resultSelector) { var i = collection.Count; foreach (var item in collection) yield return resultSelector(item, i-- <= count ? i : null); } - IEnumerable IterateSequence() + static IEnumerable IterateSequence( + IEnumerable source, + int count, + Func resultSelector) { var queue = new Queue(Math.Max(1, count + 1)); diff --git a/MoreLinq/DistinctBy.cs b/MoreLinq/DistinctBy.cs index 1079ff814..834e60f70 100644 --- a/MoreLinq/DistinctBy.cs +++ b/MoreLinq/DistinctBy.cs @@ -78,7 +78,12 @@ public static IEnumerable DistinctBy(this IEnumerable _() + return _(source, keySelector, comparer); + + static IEnumerable _( + IEnumerable source, + Func keySelector, + IEqualityComparer? comparer) { var knownKeys = new HashSet(comparer); foreach (var element in source) diff --git a/MoreLinq/EndsWith.cs b/MoreLinq/EndsWith.cs index d414a3dc0..99ce9428f 100644 --- a/MoreLinq/EndsWith.cs +++ b/MoreLinq/EndsWith.cs @@ -78,14 +78,14 @@ public static bool EndsWith(this IEnumerable first, IEnumerable second, return second.TryAsCollectionLike() is { Count: var secondCount } ? first.TryAsCollectionLike() is { Count: var firstCount } && secondCount > firstCount ? false - : Impl(second, secondCount) - : Impl(secondList = second.ToList(), secondList.Count); + : Impl(first, second, secondCount, comparer) + : Impl(first, secondList = second.ToList(), secondList.Count, comparer); #pragma warning restore IDE0075 // Simplify conditional expression - bool Impl(IEnumerable snd, int count) + static bool Impl(IEnumerable first, IEnumerable second, int count, IEqualityComparer comparer) { using var firstIter = first.TakeLast(count).GetEnumerator(); - return snd.All(item => firstIter.MoveNext() && comparer.Equals(firstIter.Current, item)); + return second.All(item => firstIter.MoveNext() && comparer.Equals(firstIter.Current, item)); } } } diff --git a/MoreLinq/ExceptBy.cs b/MoreLinq/ExceptBy.cs index 6a5e1f2c6..2a8fe7911 100644 --- a/MoreLinq/ExceptBy.cs +++ b/MoreLinq/ExceptBy.cs @@ -79,9 +79,13 @@ public static IEnumerable ExceptBy(this IEnumerable Impl() + static IEnumerable Impl( + IEnumerable first, + IEnumerable second, + Func keySelector, + IEqualityComparer? keyComparer) { // TODO Use ToHashSet var keys = new HashSet(second.Select(keySelector), keyComparer); diff --git a/MoreLinq/Exclude.cs b/MoreLinq/Exclude.cs index 455861862..6d416d0fa 100644 --- a/MoreLinq/Exclude.cs +++ b/MoreLinq/Exclude.cs @@ -41,10 +41,10 @@ public static IEnumerable Exclude(this IEnumerable sequence, int startI { < 0 => throw new ArgumentOutOfRangeException(nameof(count)), 0 => sequence, - _ => _() + _ => _(sequence, startIndex, count) }; - IEnumerable _() + static IEnumerable _(IEnumerable sequence, int startIndex, int count) { var index = 0; var endIndex = startIndex + count; diff --git a/MoreLinq/Experimental/Async/Merge.cs b/MoreLinq/Experimental/Async/Merge.cs index f414eaa7d..03ae97c82 100644 --- a/MoreLinq/Experimental/Async/Merge.cs +++ b/MoreLinq/Experimental/Async/Merge.cs @@ -85,9 +85,9 @@ public static IAsyncEnumerable Merge(this IEnumerable> if (sources is null) throw new ArgumentNullException(nameof(sources)); if (maxConcurrent <= 0) throw new ArgumentOutOfRangeException(nameof(maxConcurrent)); - return Async(); + return Async(sources, maxConcurrent); - async IAsyncEnumerable Async([EnumeratorCancellation]CancellationToken cancellationToken = default) + static async IAsyncEnumerable Async(IEnumerable> sources, int maxConcurrent, [EnumeratorCancellation]CancellationToken cancellationToken = default) { using var thisCancellationTokenSource = new CancellationTokenSource(); diff --git a/MoreLinq/Experimental/Await.cs b/MoreLinq/Experimental/Await.cs index 717a209bc..dca801b51 100644 --- a/MoreLinq/Experimental/Await.cs +++ b/MoreLinq/Experimental/Await.cs @@ -424,11 +424,20 @@ public static IAwaitQuery AwaitCompletion( return AwaitQuery.Create( - options => Impl(options.MaxConcurrency, + options => Impl(source, + evaluator, + resultSelector, + options.MaxConcurrency, options.Scheduler ?? TaskScheduler.Default, options.PreserveOrder)); - IEnumerable Impl(int? maxConcurrency, TaskScheduler scheduler, bool ordered) + static IEnumerable Impl( + IEnumerable source, + Func> evaluator, + Func, TResult> resultSelector, + int? maxConcurrency, + TaskScheduler scheduler, + bool ordered) { // A separate task will enumerate the source and launch tasks. // It will post all progress as notices to the collection below. diff --git a/MoreLinq/Experimental/Batch.cs b/MoreLinq/Experimental/Batch.cs index 9e9c28425..d3c444804 100644 --- a/MoreLinq/Experimental/Batch.cs +++ b/MoreLinq/Experimental/Batch.cs @@ -145,7 +145,12 @@ public static IEnumerable if (bucketProjectionSelector == null) throw new ArgumentNullException(nameof(bucketProjectionSelector)); if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return _(); IEnumerable _() + return _(source, size, pool, bucketProjectionSelector, resultSelector); + + static IEnumerable _( + IEnumerable source, int size, ArrayPool pool, + Func, IEnumerable> bucketProjectionSelector, + Func, TResult> resultSelector) { using var batch = source.Batch(size, pool); var bucket = bucketProjectionSelector(batch.CurrentBuffer); diff --git a/MoreLinq/FallbackIfEmpty.cs b/MoreLinq/FallbackIfEmpty.cs index 159a7de4f..a54db158c 100644 --- a/MoreLinq/FallbackIfEmpty.cs +++ b/MoreLinq/FallbackIfEmpty.cs @@ -161,7 +161,16 @@ static IEnumerable FallbackIfEmptyImpl(IEnumerable source, int? count, T? fallback1, T? fallback2, T? fallback3, T? fallback4, IEnumerable? fallback) { - return _(); IEnumerable _() + return _(source, count, fallback1, fallback2, fallback3, fallback4, fallback); + + static IEnumerable _( + IEnumerable source, + int? count, + T? fallback1, + T? fallback2, + T? fallback3, + T? fallback4, + IEnumerable? fallback) { if (source.TryAsCollectionLike() is null or { Count: > 0 }) { diff --git a/MoreLinq/Flatten.cs b/MoreLinq/Flatten.cs index eaee331d2..b2f5eb739 100644 --- a/MoreLinq/Flatten.cs +++ b/MoreLinq/Flatten.cs @@ -118,14 +118,20 @@ public static IEnumerable< if (source == null) throw new ArgumentNullException(nameof(source)); if (selector == null) throw new ArgumentNullException(nameof(selector)); - return _(); + return _(source, selector); - IEnumerable< + static IEnumerable< // Just like "IEnumerable.Current" is null-oblivious, so is this: #nullable disable -/*...................*/ object +/*..........................*/ object #nullable restore -/*.........................*/ > _() +/*.................................*/ > _(IEnumerable source, + Func< +// Just like "IEnumerable.Current" is null-oblivious, so is this: +#nullable disable +/*..........................................*/ object, +#nullable restore +/*..................................................*/ IEnumerable?> selector) { var e = source.GetEnumerator(); var stack = new Stack(); diff --git a/MoreLinq/From.cs b/MoreLinq/From.cs index b9bf76faa..bf2e826d6 100644 --- a/MoreLinq/From.cs +++ b/MoreLinq/From.cs @@ -36,7 +36,9 @@ partial class MoreEnumerable public static IEnumerable From(Func function) { - return _(); IEnumerable _() + return _(function); + + static IEnumerable _(Func function) { #pragma warning disable CA1062 // Validate arguments of public methods yield return function(); @@ -59,7 +61,9 @@ public static IEnumerable From(Func function) public static IEnumerable From(Func function1, Func function2) { - return _(); IEnumerable _() + return _(function1, function2); + + static IEnumerable _(Func function1, Func function2) { #pragma warning disable CA1062 // Validate arguments of public methods yield return function1(); @@ -84,7 +88,9 @@ public static IEnumerable From(Func function1, Func function2) public static IEnumerable From(Func function1, Func function2, Func function3) { - return _(); IEnumerable _() + return _(function1, function2, function3); + + static IEnumerable _(Func function1, Func function2, Func function3) { #pragma warning disable CA1062 // Validate arguments of public methods yield return function1(); diff --git a/MoreLinq/FullGroupJoin.cs b/MoreLinq/FullGroupJoin.cs index 2f6fb56c8..455940cc0 100644 --- a/MoreLinq/FullGroupJoin.cs +++ b/MoreLinq/FullGroupJoin.cs @@ -146,9 +146,15 @@ public static IEnumerable FullGroupJoin if (secondKeySelector == null) throw new ArgumentNullException(nameof(secondKeySelector)); if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return _(comparer ?? EqualityComparer.Default); + return _(first, second, firstKeySelector, secondKeySelector, resultSelector, comparer ?? EqualityComparer.Default); - IEnumerable _(IEqualityComparer comparer) + static IEnumerable _( + IEnumerable first, + IEnumerable second, + Func firstKeySelector, + Func secondKeySelector, + Func, IEnumerable, TResult> resultSelector, + IEqualityComparer comparer) { var alookup = Lookup.CreateForJoin(first, firstKeySelector, comparer); var blookup = Lookup.CreateForJoin(second, secondKeySelector, comparer); diff --git a/MoreLinq/FullJoin.cs b/MoreLinq/FullJoin.cs index 9b2da6d12..6d59386e7 100644 --- a/MoreLinq/FullJoin.cs +++ b/MoreLinq/FullJoin.cs @@ -228,9 +228,17 @@ public static IEnumerable FullJoin( if (secondSelector == null) throw new ArgumentNullException(nameof(secondSelector)); if (bothSelector == null) throw new ArgumentNullException(nameof(bothSelector)); - return Impl(); + return Impl(first, second, firstKeySelector, secondKeySelector, firstSelector, secondSelector, bothSelector, comparer); - IEnumerable Impl() + static IEnumerable Impl( + IEnumerable first, + IEnumerable second, + Func firstKeySelector, + Func secondKeySelector, + Func firstSelector, + Func secondSelector, + Func bothSelector, + IEqualityComparer? comparer) { var seconds = second.Select(e => new KeyValuePair(secondKeySelector(e), e)).ToArray(); var secondLookup = seconds.ToLookup(e => e.Key, e => e.Value, comparer); diff --git a/MoreLinq/Generate.cs b/MoreLinq/Generate.cs index a15b38486..519e9785f 100644 --- a/MoreLinq/Generate.cs +++ b/MoreLinq/Generate.cs @@ -45,7 +45,9 @@ public static IEnumerable Generate(TResult initial, Func _() + return _(initial, generator); + + static IEnumerable _(TResult initial, Func generator) { var current = initial; while (true) diff --git a/MoreLinq/Insert.cs b/MoreLinq/Insert.cs index 11c337ba3..774a7df9f 100644 --- a/MoreLinq/Insert.cs +++ b/MoreLinq/Insert.cs @@ -55,7 +55,9 @@ public static IEnumerable Insert(this IEnumerable first, IEnumerable if (second == null) throw new ArgumentNullException(nameof(second)); if (index < 0) throw new ArgumentOutOfRangeException(nameof(index), "Index cannot be negative."); - return _(); IEnumerable _() + return _(first, second, index); + + static IEnumerable _(IEnumerable first, IEnumerable second, int index) { var i = -1; diff --git a/MoreLinq/Lag.cs b/MoreLinq/Lag.cs index 4b532a649..f3ac4cacb 100644 --- a/MoreLinq/Lag.cs +++ b/MoreLinq/Lag.cs @@ -83,7 +83,13 @@ public static IEnumerable Lag(this IEnumerable _() + return _(source, offset, defaultLagValue, resultSelector); + + static IEnumerable _( + IEnumerable source, + int offset, + TSource defaultLagValue, + Func resultSelector) { using var iter = source.GetEnumerator(); diff --git a/MoreLinq/Lead.cs b/MoreLinq/Lead.cs index 2a0b7cbb3..392e55b99 100644 --- a/MoreLinq/Lead.cs +++ b/MoreLinq/Lead.cs @@ -80,7 +80,13 @@ public static IEnumerable Lead(this IEnumerable _() + return _(source, offset, defaultLeadValue, resultSelector); + + static IEnumerable _( + IEnumerable source, + int offset, + TSource defaultLeadValue, + Func resultSelector) { var leadQueue = new Queue(offset); using var iter = source.GetEnumerator(); diff --git a/MoreLinq/Maxima.cs b/MoreLinq/Maxima.cs index 645ea374d..9f4a35c1a 100644 --- a/MoreLinq/Maxima.cs +++ b/MoreLinq/Maxima.cs @@ -312,10 +312,13 @@ static IEnumerable ExtremaBy( Extrema extrema, int? limit, Func selector, Func comparer) { - foreach (var item in Extrema()) + foreach (var item in Extrema(source, extrema, limit, selector, comparer)) yield return item; - IEnumerable Extrema() + static IEnumerable Extrema( + IEnumerable source, + Extrema extrema, int? limit, + Func selector, Func comparer) { using var e = source.GetEnumerator(); diff --git a/MoreLinq/Move.cs b/MoreLinq/Move.cs index 43e38d2d7..73dbfc849 100644 --- a/MoreLinq/Move.cs +++ b/MoreLinq/Move.cs @@ -58,10 +58,10 @@ public static IEnumerable Move(this IEnumerable source, int fromIndex, return source; return toIndex < fromIndex - ? _(toIndex, fromIndex - toIndex, count) - : _(fromIndex, count, toIndex - fromIndex); + ? _(source, toIndex, fromIndex - toIndex, count) + : _(source, fromIndex, count, toIndex - fromIndex); - IEnumerable _(int bufferStartIndex, int bufferSize, int bufferYieldIndex) + static IEnumerable _(IEnumerable source, int bufferStartIndex, int bufferSize, int bufferYieldIndex) { var hasMore = true; bool MoveNext(IEnumerator e) => hasMore && (hasMore = e.MoveNext()); diff --git a/MoreLinq/OrderedMerge.cs b/MoreLinq/OrderedMerge.cs index 0e30e1517..3f4a7e5e8 100644 --- a/MoreLinq/OrderedMerge.cs +++ b/MoreLinq/OrderedMerge.cs @@ -282,9 +282,24 @@ public static IEnumerable OrderedMerge( if (bothSelector == null) throw new ArgumentNullException(nameof(bothSelector)); if (secondSelector == null) throw new ArgumentNullException(nameof(secondSelector)); - return _(comparer ?? Comparer.Default); + return _(first, + second, + firstKeySelector, + secondKeySelector, + firstSelector, + secondSelector, + bothSelector, + comparer ?? Comparer.Default); - IEnumerable _(IComparer comparer) + static IEnumerable _( + IEnumerable first, + IEnumerable second, + Func firstKeySelector, + Func secondKeySelector, + Func firstSelector, + Func secondSelector, + Func bothSelector, + IComparer comparer) { using var e1 = first.GetEnumerator(); using var e2 = second.GetEnumerator(); diff --git a/MoreLinq/PadStart.cs b/MoreLinq/PadStart.cs index 5e9e380d1..639e15305 100644 --- a/MoreLinq/PadStart.cs +++ b/MoreLinq/PadStart.cs @@ -117,7 +117,13 @@ public static IEnumerable PadStart(this IEnumerable s static IEnumerable PadStartImpl(IEnumerable source, int width, T? padding, Func? paddingSelector) { - return _(); IEnumerable _() + return _(source, width, padding, paddingSelector); + + static IEnumerable _( + IEnumerable source, + int width, + T? padding, + Func? paddingSelector) { if (source.TryAsCollectionLike() is { Count: var collectionCount } && collectionCount < width) { diff --git a/MoreLinq/Pairwise.cs b/MoreLinq/Pairwise.cs index 9e262e85d..6b9c4347d 100644 --- a/MoreLinq/Pairwise.cs +++ b/MoreLinq/Pairwise.cs @@ -53,7 +53,9 @@ public static IEnumerable Pairwise(this IEnumerable _() + return _(source, resultSelector); + + static IEnumerable _(IEnumerable source, Func resultSelector) { using var e = source.GetEnumerator(); diff --git a/MoreLinq/Permutations.cs b/MoreLinq/Permutations.cs index 2324750bb..dd60235a4 100644 --- a/MoreLinq/Permutations.cs +++ b/MoreLinq/Permutations.cs @@ -49,7 +49,9 @@ public static IEnumerable> Permutations(this IEnumerable sequence { if (sequence == null) throw new ArgumentNullException(nameof(sequence)); - return _(); IEnumerable> _() + return _(sequence); + + static IEnumerable> _(IEnumerable sequence) { // The algorithm used to generate permutations uses the fact that any set can be put // into 1-to-1 correspondence with the set of ordinals number (0..n). The diff --git a/MoreLinq/Pipe.cs b/MoreLinq/Pipe.cs index 474ef725e..94c5c6138 100644 --- a/MoreLinq/Pipe.cs +++ b/MoreLinq/Pipe.cs @@ -43,7 +43,9 @@ public static IEnumerable Pipe(this IEnumerable source, Action actio if (source == null) throw new ArgumentNullException(nameof(source)); if (action == null) throw new ArgumentNullException(nameof(action)); - return _(); IEnumerable _() + return _(source, action); + + static IEnumerable _(IEnumerable source, Action action) { foreach (var element in source) { diff --git a/MoreLinq/PreScan.cs b/MoreLinq/PreScan.cs index 88aa8f57c..a23763722 100644 --- a/MoreLinq/PreScan.cs +++ b/MoreLinq/PreScan.cs @@ -59,7 +59,12 @@ public static IEnumerable PreScan( if (source == null) throw new ArgumentNullException(nameof(source)); if (transformation == null) throw new ArgumentNullException(nameof(transformation)); - return _(); IEnumerable _() + return _(source, transformation, identity); + + static IEnumerable _( + IEnumerable source, + Func transformation, + TSource identity) { var aggregator = identity; using var e = source.GetEnumerator(); diff --git a/MoreLinq/Rank.cs b/MoreLinq/Rank.cs index 4e5586382..4232fac00 100644 --- a/MoreLinq/Rank.cs +++ b/MoreLinq/Rank.cs @@ -77,9 +77,9 @@ public static IEnumerable RankBy(this IEnumerable s if (source == null) throw new ArgumentNullException(nameof(source)); if (keySelector == null) throw new ArgumentNullException(nameof(keySelector)); - return _(comparer ?? Comparer.Default); + return _(source, keySelector, comparer ?? Comparer.Default); - IEnumerable _(IComparer comparer) + static IEnumerable _(IEnumerable source, Func keySelector, IComparer comparer) { source = source.ToArray(); // avoid enumerating source twice diff --git a/MoreLinq/RunLengthEncode.cs b/MoreLinq/RunLengthEncode.cs index 232c38e37..f701de31f 100644 --- a/MoreLinq/RunLengthEncode.cs +++ b/MoreLinq/RunLengthEncode.cs @@ -49,9 +49,9 @@ public static IEnumerable> RunLengthEncode(this IEnumera { if (sequence == null) throw new ArgumentNullException(nameof(sequence)); - return _(comparer ?? EqualityComparer.Default); + return _(sequence, comparer ?? EqualityComparer.Default); - IEnumerable> _(IEqualityComparer comparer) + static IEnumerable> _(IEnumerable sequence, IEqualityComparer comparer) { // This implementation could also have been written using a foreach loop, // but it proved to be easier to deal with edge certain cases that occur diff --git a/MoreLinq/ScanBy.cs b/MoreLinq/ScanBy.cs index 3ca138ced..d12d1de7f 100644 --- a/MoreLinq/ScanBy.cs +++ b/MoreLinq/ScanBy.cs @@ -85,9 +85,14 @@ public static IEnumerable> ScanBy.Default); + return _(source, keySelector, seedSelector, accumulator, comparer ?? EqualityComparer.Default); - IEnumerable> _(IEqualityComparer comparer) + static IEnumerable> _( + IEnumerable source, + Func keySelector, + Func seedSelector, + Func accumulator, + IEqualityComparer comparer) { var stateByKey = new Collections.Dictionary(comparer); diff --git a/MoreLinq/Segment.cs b/MoreLinq/Segment.cs index 859f59014..e29ecdce0 100644 --- a/MoreLinq/Segment.cs +++ b/MoreLinq/Segment.cs @@ -74,7 +74,9 @@ public static IEnumerable> Segment(this IEnumerable source, if (source == null) throw new ArgumentNullException(nameof(source)); if (newSegmentPredicate == null) throw new ArgumentNullException(nameof(newSegmentPredicate)); - return _(); IEnumerable> _() + return _(source, newSegmentPredicate); + + static IEnumerable> _(IEnumerable source, Func newSegmentPredicate) { using var e = source.GetEnumerator(); diff --git a/MoreLinq/SkipUntil.cs b/MoreLinq/SkipUntil.cs index 7a738c35c..07a45f667 100644 --- a/MoreLinq/SkipUntil.cs +++ b/MoreLinq/SkipUntil.cs @@ -57,7 +57,9 @@ public static IEnumerable SkipUntil(this IEnumerable if (source == null) throw new ArgumentNullException(nameof(source)); if (predicate == null) throw new ArgumentNullException(nameof(predicate)); - return _(); IEnumerable _() + return _(source, predicate); + + static IEnumerable _(IEnumerable source, Func predicate) { using var enumerator = source.GetEnumerator(); diff --git a/MoreLinq/Slice.cs b/MoreLinq/Slice.cs index 86f8306fa..5867d58fa 100644 --- a/MoreLinq/Slice.cs +++ b/MoreLinq/Slice.cs @@ -55,12 +55,12 @@ public static IEnumerable Slice(this IEnumerable sequence, int startInd return sequence switch { - IList list => SliceList(list.Count, i => list[i]), - IReadOnlyList list => SliceList(list.Count, i => list[i]), + IList list => SliceList(startIndex, count, list.Count, i => list[i]), + IReadOnlyList list => SliceList(startIndex, count, list.Count, i => list[i]), var seq => seq.Skip(startIndex).Take(count) }; - IEnumerable SliceList(int listCount, Func indexer) + static IEnumerable SliceList(int startIndex, int count, int listCount, Func indexer) { var countdown = count; var index = startIndex; diff --git a/MoreLinq/SortedMerge.cs b/MoreLinq/SortedMerge.cs index 03757dcb5..04d328099 100644 --- a/MoreLinq/SortedMerge.cs +++ b/MoreLinq/SortedMerge.cs @@ -96,7 +96,7 @@ public static IEnumerable SortedMerge(this IEnumerable comparer.Compare(b, a) > 0; // return the sorted merge result - return Impl(new[] { source }.Concat(otherSequences)); + return Impl(new[] { source }.Concat(otherSequences), precedenceFunc); // Private implementation method that performs a merge of multiple, ordered sequences using // a precedence function which encodes order-sensitive comparison logic based on the caller's arguments. @@ -109,7 +109,7 @@ public static IEnumerable SortedMerge(this IEnumerableN => otherSequences.Count()+1. - IEnumerable Impl(IEnumerable> sequences) + static IEnumerable Impl(IEnumerable> sequences, Func precedenceFunc) { using var disposables = new DisposableGroup(sequences.Select(e => e.GetEnumerator()).Acquire()); diff --git a/MoreLinq/Split.cs b/MoreLinq/Split.cs index 935537aa5..5edb1f0ba 100644 --- a/MoreLinq/Split.cs +++ b/MoreLinq/Split.cs @@ -267,7 +267,13 @@ public static IEnumerable Split(this IEnumerable _() + return _(source, separatorFunc, count, resultSelector); + + static IEnumerable _( + IEnumerable source, + Func separatorFunc, + int count, + Func, TResult> resultSelector) { if (count == 0) // No splits? { diff --git a/MoreLinq/Subsets.cs b/MoreLinq/Subsets.cs index f1167152f..9ffe27f05 100644 --- a/MoreLinq/Subsets.cs +++ b/MoreLinq/Subsets.cs @@ -51,7 +51,9 @@ public static IEnumerable> Subsets(this IEnumerable sequence) { if (sequence == null) throw new ArgumentNullException(nameof(sequence)); - return _(); IEnumerable> _() + return _(sequence); + + static IEnumerable> _(IEnumerable sequence) { var sequenceAsList = sequence.ToList(); var sequenceLength = sequenceAsList.Count; @@ -113,7 +115,9 @@ public static IEnumerable> Subsets(this IEnumerable sequence, int // preconditions. This however, needs to be carefully considered - and perhaps // may change after further thought and review. - return _(); IEnumerable> _() + return _(sequence, subsetSize); + + static IEnumerable> _(IEnumerable sequence, int subsetSize) { foreach (var subset in Subsets(sequence.ToList(), subsetSize)) yield return subset; diff --git a/MoreLinq/TagFirstLast.cs b/MoreLinq/TagFirstLast.cs index 61d90f6e7..705b22a04 100644 --- a/MoreLinq/TagFirstLast.cs +++ b/MoreLinq/TagFirstLast.cs @@ -59,7 +59,9 @@ public static IEnumerable TagFirstLast(this IEnumerab if (source == null) throw new ArgumentNullException(nameof(source)); if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return _(); IEnumerable _() + return _(source, resultSelector); + + static IEnumerable _(IEnumerable source, Func resultSelector) { using var enumerator = source.GetEnumerator(); diff --git a/MoreLinq/TakeUntil.cs b/MoreLinq/TakeUntil.cs index bceb05c22..3488a3bec 100644 --- a/MoreLinq/TakeUntil.cs +++ b/MoreLinq/TakeUntil.cs @@ -57,7 +57,9 @@ public static IEnumerable TakeUntil(this IEnumerable if (source == null) throw new ArgumentNullException(nameof(source)); if (predicate == null) throw new ArgumentNullException(nameof(predicate)); - return _(); IEnumerable _() + return _(source, predicate); + + static IEnumerable _(IEnumerable source, Func predicate) { foreach (var item in source) { diff --git a/MoreLinq/Transpose.cs b/MoreLinq/Transpose.cs index eb1a151bd..e6841a9ca 100644 --- a/MoreLinq/Transpose.cs +++ b/MoreLinq/Transpose.cs @@ -56,7 +56,9 @@ public static IEnumerable> Transpose(this IEnumerable> _() + return _(source); + + static IEnumerable> _(IEnumerable> source) { #pragma warning disable IDE0007 // Use implicit type (false positive) IEnumerator?[] enumerators = source.Select(e => e.GetEnumerator()).Acquire(); diff --git a/MoreLinq/Traverse.cs b/MoreLinq/Traverse.cs index 4fb46b5b8..1ec5b0d9b 100644 --- a/MoreLinq/Traverse.cs +++ b/MoreLinq/Traverse.cs @@ -48,7 +48,9 @@ public static IEnumerable TraverseBreadthFirst(T root, Func _() + return _(root, childrenSelector); + + static IEnumerable _(T root, Func> childrenSelector) { var queue = new Queue(); queue.Enqueue(root); @@ -88,7 +90,9 @@ public static IEnumerable TraverseDepthFirst(T root, Func _() + return _(root, childrenSelector); + + static IEnumerable _(T root, Func> childrenSelector) { var stack = new Stack(); stack.Push(root); diff --git a/MoreLinq/Unfold.cs b/MoreLinq/Unfold.cs index d6f5b8738..380a10858 100644 --- a/MoreLinq/Unfold.cs +++ b/MoreLinq/Unfold.cs @@ -61,7 +61,14 @@ public static IEnumerable Unfold( if (stateSelector == null) throw new ArgumentNullException(nameof(stateSelector)); if (resultSelector == null) throw new ArgumentNullException(nameof(resultSelector)); - return _(state); IEnumerable _(TState initialState) + return _(state, generator, predicate, stateSelector, resultSelector); + + static IEnumerable _( + TState initialState, + Func generator, + Func predicate, + Func stateSelector, + Func resultSelector) { for (var state = initialState; ;) { diff --git a/MoreLinq/Window.cs b/MoreLinq/Window.cs index 04b1ddefd..e3de531f7 100644 --- a/MoreLinq/Window.cs +++ b/MoreLinq/Window.cs @@ -44,7 +44,9 @@ public static IEnumerable> Window(this IEnumerable> _() + return _(source, size); + + static IEnumerable> _(IEnumerable source, int size) { using var iter = source.GetEnumerator(); diff --git a/MoreLinq/WindowLeft.cs b/MoreLinq/WindowLeft.cs index fdcd72803..43dc0ad8a 100644 --- a/MoreLinq/WindowLeft.cs +++ b/MoreLinq/WindowLeft.cs @@ -63,7 +63,9 @@ public static IEnumerable> WindowLeft(this IEnumerable> _() + return _(source, size); + + static IEnumerable> _(IEnumerable source, int size) { var window = new List(); foreach (var item in source) diff --git a/MoreLinq/WindowRight.cs b/MoreLinq/WindowRight.cs index 4172c3d6d..52bd9a050 100644 --- a/MoreLinq/WindowRight.cs +++ b/MoreLinq/WindowRight.cs @@ -78,7 +78,11 @@ static IEnumerable> WindowRightWhile( if (source == null) throw new ArgumentNullException(nameof(source)); if (predicate == null) throw new ArgumentNullException(nameof(predicate)); - return _(); IEnumerable> _() + return _(source, predicate); + + static IEnumerable> _( + IEnumerable source, + Func predicate) { var window = new List(); foreach (var item in source) From bd10cf9d10e400de2f634917787c047f9d687974 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 6 May 2024 22:39:58 +0500 Subject: [PATCH 148/157] Update NuGet package validation tool to latest version --- .config/dotnet-tools.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json index a3de0d7a5..890982194 100644 --- a/.config/dotnet-tools.json +++ b/.config/dotnet-tools.json @@ -15,7 +15,7 @@ ] }, "meziantou.framework.nugetpackagevalidation.tool": { - "version": "1.0.12", + "version": "1.0.14", "commands": [ "meziantou.validate-nuget-package" ] From 9a2cc9f3a0fe94ea11a0be1371c97c2e7ac01568 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 6 May 2024 22:10:15 +0200 Subject: [PATCH 149/157] Remove testing against .NET 7 (near end-of-life) .NET 7 reaches end-of-life on May 14, 2024: https://dotnet.microsoft.com/en-us/download/dotnet/7.0 --- .github/workflows/build.yml | 5 ----- MoreLinq.Test/MoreLinq.Test.csproj | 2 +- appveyor.yml | 2 -- test.cmd | 2 -- test.sh | 2 +- 5 files changed, 2 insertions(+), 11 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index f51ded59d..d7edc5aab 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -58,11 +58,6 @@ jobs: with: global-json-file: global.json - - name: Setup .NET SDK 7.0 - uses: actions/setup-dotnet@v3 - with: - dotnet-version: 7.0.x - - name: Setup .NET SDK 6.0 uses: actions/setup-dotnet@v3 with: diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index 413e5e7f4..5defc11f4 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -2,7 +2,7 @@ MoreLinq.Test - net8.0;net7.0;net6.0;net471 + net8.0;net6.0;net471 portable MoreLinq.Test Exe diff --git a/appveyor.yml b/appveyor.yml index c7f50f424..646a17b24 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -52,10 +52,8 @@ install: - git reset --hard - ps: if ($isWindows) { tools\dotnet-install.ps1 -JSonFile global.json } - ps: if ($isWindows) { tools\dotnet-install.ps1 -Runtime dotnet -Version 6.0.11 -SkipNonVersionedFiles } -- ps: if ($isWindows) { tools\dotnet-install.ps1 -Runtime dotnet -Version 7.0.14 -SkipNonVersionedFiles } - sh: ./tools/dotnet-install.sh --jsonfile global.json - sh: ./tools/dotnet-install.sh --runtime dotnet --version 6.0.11 --skip-non-versioned-files -- sh: ./tools/dotnet-install.sh --runtime dotnet --version 7.0.14 --skip-non-versioned-files - sh: export PATH="$HOME/.dotnet:$PATH" before_build: - dotnet --info diff --git a/test.cmd b/test.cmd index 640f802b9..a6d28730d 100644 --- a/test.cmd +++ b/test.cmd @@ -10,8 +10,6 @@ if %SKIP_TEST_BUILD%==false call build || exit /b 1 call :clean ^ && call :test net8.0 Debug ^ && call :test net8.0 Release ^ - && call :test net7.0 Debug ^ - && call :test net7.0 Release ^ && call :test net6.0 Debug ^ && call :test net6.0 Release ^ && call :test net471 Debug ^ diff --git a/test.sh b/test.sh index fbe65fd50..9bd9806a0 100755 --- a/test.sh +++ b/test.sh @@ -12,7 +12,7 @@ if [[ -z "$1" ]]; then else configs="$1" fi -for f in net6.0 net7.0 net8.0; do +for f in net6.0 net8.0; do for c in $configs; do dotnet test --no-build -c $c -f $f --settings MoreLinq.Test/coverlet.runsettings MoreLinq.Test TEST_RESULTS_DIR="$(ls -dc MoreLinq.Test/TestResults/* | head -1)" From bb478ee905fbd516dd4c1e4b3e7911767e863232 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Mon, 20 May 2024 14:11:00 +0200 Subject: [PATCH 150/157] Pin to .NET SDK 8.0.2xx --- global.json | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/global.json b/global.json index 391ba3c2a..d031a7632 100644 --- a/global.json +++ b/global.json @@ -1,6 +1,6 @@ { "sdk": { - "version": "8.0.100", - "rollForward": "latestFeature" + "version": "8.0.200", + "rollForward": "latestPatch" } } From 2bedad6e79e05e0ece5ce5c605ca243ed1061902 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 6 Jul 2024 15:25:24 +0200 Subject: [PATCH 151/157] Enable Native AOT compatibility (trimming support) This is a squashed merge of PR #1070. --- MoreLinq.Test.Aot/MoreLinq.Test.Aot.csproj | 32 +++ MoreLinq.Test.Aot/ToDataTableTest.cs | 235 +++++++++++++++++++++ MoreLinq.Test/Throws.cs | 9 +- MoreLinq.Test/ToDataTableTest.cs | 32 +-- MoreLinq.sln | 6 + MoreLinq/Extensions.ToDataTable.g.cs | 18 +- MoreLinq/MoreLinq.csproj | 9 + MoreLinq/ToDataTable.cs | 148 ++++++++++--- test.cmd | 21 +- test.sh | 2 + 10 files changed, 456 insertions(+), 56 deletions(-) create mode 100644 MoreLinq.Test.Aot/MoreLinq.Test.Aot.csproj create mode 100644 MoreLinq.Test.Aot/ToDataTableTest.cs diff --git a/MoreLinq.Test.Aot/MoreLinq.Test.Aot.csproj b/MoreLinq.Test.Aot/MoreLinq.Test.Aot.csproj new file mode 100644 index 000000000..9453f8dc7 --- /dev/null +++ b/MoreLinq.Test.Aot/MoreLinq.Test.Aot.csproj @@ -0,0 +1,32 @@ + + + + net8.0 + exe + false + true + + + + + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + + + diff --git a/MoreLinq.Test.Aot/ToDataTableTest.cs b/MoreLinq.Test.Aot/ToDataTableTest.cs new file mode 100644 index 000000000..163c76598 --- /dev/null +++ b/MoreLinq.Test.Aot/ToDataTableTest.cs @@ -0,0 +1,235 @@ +#region License and Terms +// MoreLINQ - Extensions to LINQ to Objects +// Copyright (c) 2024 Atif Aziz. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#endregion + +namespace MoreLinq.Test +{ + using System; + using System.Collections; + using System.Collections.Generic; + using System.Data; + using System.Diagnostics.CodeAnalysis; + using System.Linq; + using System.Linq.Expressions; + + [TestClass] + public class ToDataTableTest + { + sealed class TestObject(int key) + { + public int KeyField = key; + public Guid? ANullableGuidField = Guid.NewGuid(); + + public string AString { get; } = "ABCDEFGHIKKLMNOPQRSTUVWXYSZ"; + public decimal? ANullableDecimal { get; } = key / 3; + public object Unreadable { set => throw new NotImplementedException(); } + + public object this[int index] { get => new(); set { } } + + public override string ToString() => nameof(TestObject); + } + + readonly IReadOnlyCollection testObjects; + + public ToDataTableTest() => + this.testObjects = Enumerable.Range(0, 3) + .Select(i => new TestObject(i)) + .ToArray(); + + [TestMethod] + public void ToDataTableNullMemberExpressionMethod() + { + Expression>? expression = null; + + [UnconditionalSuppressMessage("Aot", "IL2026")] + void Act() => _ = this.testObjects.ToDataTable(expression!); + + var e = Assert.ThrowsException(Act); + Assert.AreEqual("expressions", e.ParamName); + } + + [TestMethod] + public void ToDataTableTableWithWrongColumnNames() + { + using var dt = new DataTable(); + _ = dt.Columns.Add("Test"); + + [UnconditionalSuppressMessage("Aot", "IL2026")] + void Act() => _ = this.testObjects.ToDataTable(dt); + + var e = Assert.ThrowsException(Act); + Assert.AreEqual("table", e.ParamName); + } + + [TestMethod] + public void ToDataTableTableWithWrongColumnDataType() + { + using var dt = new DataTable(); + _ = dt.Columns.Add("AString", typeof(int)); + + [UnconditionalSuppressMessage("Aot", "IL2026")] + void Act() => _ = this.testObjects.ToDataTable(dt, t => t.AString); + + var e = Assert.ThrowsException(Act); + Assert.AreEqual("table", e.ParamName); + } + + void TestDataTableMemberExpression(Expression> expression) + { + [UnconditionalSuppressMessage("Aot", "IL2026")] + void Act() => _ = this.testObjects.ToDataTable(expression); + + var e = Assert.ThrowsException(Act); + Assert.AreEqual("expressions", e.ParamName); + var innerException = e.InnerException; + Assert.IsNotNull(innerException); + Assert.IsInstanceOfType(innerException); + Assert.AreEqual("lambda", ((ArgumentException)innerException).ParamName); + } + + [TestMethod] + public void ToDataTableMemberExpressionMethod() + { + TestDataTableMemberExpression(t => t.ToString()); + } + + [TestMethod] + public void ToDataTableMemberExpressionNonMember() + { + TestDataTableMemberExpression(t => t.ToString().Length); + } + + [TestMethod] + public void ToDataTableMemberExpressionIndexer() + { + TestDataTableMemberExpression(t => t[0]); + } + + [TestMethod] + public void ToDataTableMemberExpressionStatic() + { + TestDataTableMemberExpression(_ => DateTime.Now); + } + + [TestMethod] + public void ToDataTableSchemaInDeclarationOrder() + { + [UnconditionalSuppressMessage("Aot", "IL2026")] + DataTable Act() => this.testObjects.ToDataTable(); + + var dt = Act(); + + // Assert properties first, then fields, then in declaration order + + Assert.AreEqual("KeyField", dt.Columns[2].Caption); + Assert.AreEqual(typeof(int), dt.Columns[2].DataType); + + Assert.AreEqual("ANullableGuidField", dt.Columns[3].Caption); + Assert.AreEqual(typeof(Guid), dt.Columns[3].DataType); + Assert.IsTrue(dt.Columns[3].AllowDBNull); + + Assert.AreEqual("AString", dt.Columns[0].Caption); + Assert.AreEqual(typeof(string), dt.Columns[0].DataType); + + Assert.AreEqual("ANullableDecimal", dt.Columns[1].Caption); + Assert.AreEqual(typeof(decimal), dt.Columns[1].DataType); + + Assert.AreEqual(4, dt.Columns.Count); + } + + [TestMethod] + public void ToDataTableContainsAllElements() + { + [UnconditionalSuppressMessage("Aot", "IL2026")] + DataTable Act() => this.testObjects.ToDataTable(); + + var dt = Act(); + + Assert.AreEqual(this.testObjects.Count, dt.Rows.Count); + } + + [TestMethod] + public void ToDataTableWithExpression() + { + [UnconditionalSuppressMessage("Aot", "IL2026")] + DataTable Act() => this.testObjects.ToDataTable(t => t.AString); + + var dt = Act(); + + Assert.AreEqual("AString", dt.Columns[0].Caption); + Assert.AreEqual(typeof(string), dt.Columns[0].DataType); + + Assert.AreEqual(1, dt.Columns.Count); + } + + [TestMethod] + public void ToDataTableWithSchema() + { + using var dt = new DataTable(); + var columns = dt.Columns; + _ = columns.Add("Column1", typeof(int)); + _ = columns.Add("Value", typeof(string)); + _ = columns.Add("Column3", typeof(int)); + _ = columns.Add("Name", typeof(string)); + + var vars = Environment.GetEnvironmentVariables() + .Cast() + .ToArray(); + + [UnconditionalSuppressMessage("Aot", "IL2026")] + void Act() => _ = vars.Select(e => new { Name = e.Key.ToString(), Value = e.Value!.ToString() }) + .ToDataTable(dt, e => e.Name, e => e.Value); + + Act(); + + var rows = dt.Rows.Cast().ToArray(); + Assert.AreEqual(vars.Length, rows.Length); + CollectionAssert.AreEqual(vars.Select(e => e.Key).ToArray(), rows.Select(r => r["Name"]).ToArray()); + CollectionAssert.AreEqual(vars.Select(e => e.Value).ToArray(), rows.Select(r => r["Value"]).ToArray()); + } + + readonly struct Point(int x, int y) + { +#pragma warning disable CA1805 // Do not initialize unnecessarily (avoids CS0649) + public static Point Empty = new(); +#pragma warning restore CA1805 // Do not initialize unnecessarily + public bool IsEmpty => X == 0 && Y == 0; + public int X { get; } = x; + public int Y { get; } = y; + } + + [TestMethod] + public void ToDataTableIgnoresStaticMembers() + { + [UnconditionalSuppressMessage("Aot", "IL2026")] + static DataTable Act() => new[] { new Point(12, 34) }.ToDataTable(); + + var points = Act(); + + Assert.AreEqual(3, points.Columns.Count); + var x = points.Columns["X"]; + var y = points.Columns["Y"]; + var empty = points.Columns["IsEmpty"]; + Assert.IsNotNull(x); + Assert.IsNotNull(y); + Assert.IsNotNull(empty); + var row = points.Rows.Cast().Single(); + Assert.AreEqual(12, row[x]); + Assert.AreEqual(34, row[y]); + Assert.AreEqual(row[empty], false); + } + } +} diff --git a/MoreLinq.Test/Throws.cs b/MoreLinq.Test/Throws.cs index 672234e3c..58877a6fc 100644 --- a/MoreLinq.Test/Throws.cs +++ b/MoreLinq.Test/Throws.cs @@ -36,16 +36,19 @@ public static ExactTypeConstraint TypeOf() NUnit.Framework.Throws.TypeOf(); public static EqualConstraint ArgumentException(string expectedParamName) => - NUnit.Framework.Throws.ArgumentException.With.ParamName().EqualTo(expectedParamName); + NUnit.Framework.Throws.ArgumentException.With.ParamName(expectedParamName); public static EqualConstraint ArgumentNullException(string expectedParamName) => - NUnit.Framework.Throws.ArgumentNullException.With.ParamName().EqualTo(expectedParamName); + NUnit.Framework.Throws.ArgumentNullException.With.ParamName(expectedParamName); public static ExactTypeConstraint ArgumentOutOfRangeException() => TypeOf(); public static EqualConstraint ArgumentOutOfRangeException(string expectedParamName) => - ArgumentOutOfRangeException().With.ParamName().EqualTo(expectedParamName); + ArgumentOutOfRangeException().With.ParamName(expectedParamName); + + public static EqualConstraint ParamName(this ConstraintExpression constraint, string expectedParamName) => + constraint.ParamName().EqualTo(expectedParamName); static ResolvableConstraintExpression ParamName(this ConstraintExpression constraint) => constraint.Property(nameof(System.ArgumentException.ParamName)); diff --git a/MoreLinq.Test/ToDataTableTest.cs b/MoreLinq.Test/ToDataTableTest.cs index d6cac4cda..65958f544 100644 --- a/MoreLinq.Test/ToDataTableTest.cs +++ b/MoreLinq.Test/ToDataTableTest.cs @@ -77,33 +77,35 @@ public void ToDataTableTableWithWrongColumnDataType() Throws.ArgumentException("table")); } + void TestDataTableMemberExpression(Expression> expression) + { + Assert.That(() => this.testObjects.ToDataTable(expression), + Throws.ArgumentException("expressions") + .And.InnerException.With.ParamName("lambda")); + } + [Test] public void ToDataTableMemberExpressionMethod() { - Assert.That(() => this.testObjects.ToDataTable(t => t.ToString()), - Throws.ArgumentException("lambda")); + TestDataTableMemberExpression(t => t.ToString()); } - [Test] public void ToDataTableMemberExpressionNonMember() { - Assert.That(() => this.testObjects.ToDataTable(t => t.ToString().Length), - Throws.ArgumentException("lambda")); + TestDataTableMemberExpression(t => t.ToString().Length); } [Test] public void ToDataTableMemberExpressionIndexer() { - Assert.That(() => this.testObjects.ToDataTable(t => t[0]), - Throws.ArgumentException("lambda")); + TestDataTableMemberExpression(t => t[0]); } [Test] public void ToDataTableMemberExpressionStatic() { - Assert.That(() => _ = this.testObjects.ToDataTable(_ => DateTime.Now), - Throws.ArgumentException("lambda")); + TestDataTableMemberExpression(_ => DateTime.Now); } [Test] @@ -113,12 +115,6 @@ public void ToDataTableSchemaInDeclarationOrder() // Assert properties first, then fields, then in declaration order - Assert.That(dt.Columns[0].Caption, Is.EqualTo("AString")); - Assert.That(dt.Columns[0].DataType, Is.EqualTo(typeof(string))); - - Assert.That(dt.Columns[1].Caption, Is.EqualTo("ANullableDecimal")); - Assert.That(dt.Columns[1].DataType, Is.EqualTo(typeof(decimal))); - Assert.That(dt.Columns[2].Caption, Is.EqualTo("KeyField")); Assert.That(dt.Columns[2].DataType, Is.EqualTo(typeof(int))); @@ -126,6 +122,12 @@ public void ToDataTableSchemaInDeclarationOrder() Assert.That(dt.Columns[3].DataType, Is.EqualTo(typeof(Guid))); Assert.That(dt.Columns[3].AllowDBNull, Is.True); + Assert.That(dt.Columns[0].Caption, Is.EqualTo("AString")); + Assert.That(dt.Columns[0].DataType, Is.EqualTo(typeof(string))); + + Assert.That(dt.Columns[1].Caption, Is.EqualTo("ANullableDecimal")); + Assert.That(dt.Columns[1].DataType, Is.EqualTo(typeof(decimal))); + Assert.That(dt.Columns.Count, Is.EqualTo(4)); } diff --git a/MoreLinq.sln b/MoreLinq.sln index ff1b65d6c..d37b3cefb 100644 --- a/MoreLinq.sln +++ b/MoreLinq.sln @@ -25,6 +25,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MoreLinq.Test", "MoreLinq.T EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MoreLinq.ExtensionsGenerator", "bld\ExtensionsGenerator\MoreLinq.ExtensionsGenerator.csproj", "{5FA8F0E8-648A-4C4F-B1BB-B0C46959A36E}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MoreLinq.Test.Aot", "MoreLinq.Test.Aot\MoreLinq.Test.Aot.csproj", "{776973A3-AC2E-423E-8106-B4E296CE7752}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -43,6 +45,10 @@ Global {5FA8F0E8-648A-4C4F-B1BB-B0C46959A36E}.Debug|Any CPU.Build.0 = Debug|Any CPU {5FA8F0E8-648A-4C4F-B1BB-B0C46959A36E}.Release|Any CPU.ActiveCfg = Release|Any CPU {5FA8F0E8-648A-4C4F-B1BB-B0C46959A36E}.Release|Any CPU.Build.0 = Release|Any CPU + {776973A3-AC2E-423E-8106-B4E296CE7752}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {776973A3-AC2E-423E-8106-B4E296CE7752}.Debug|Any CPU.Build.0 = Debug|Any CPU + {776973A3-AC2E-423E-8106-B4E296CE7752}.Release|Any CPU.ActiveCfg = Release|Any CPU + {776973A3-AC2E-423E-8106-B4E296CE7752}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/MoreLinq/Extensions.ToDataTable.g.cs b/MoreLinq/Extensions.ToDataTable.g.cs index 20380243d..bf5c9ef7b 100644 --- a/MoreLinq/Extensions.ToDataTable.g.cs +++ b/MoreLinq/Extensions.ToDataTable.g.cs @@ -43,7 +43,6 @@ namespace MoreLinq.Extensions [GeneratedCode("MoreLinq.ExtensionsGenerator", "1.0.0.0")] public static partial class ToDataTableExtension { - /// /// Converts a sequence to a object. /// @@ -54,8 +53,11 @@ public static partial class ToDataTableExtension /// /// This operator uses immediate execution. - public static DataTable ToDataTable(this IEnumerable source) - => MoreEnumerable.ToDataTable(source); + [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)] + public static DataTable + ToDataTable<[DynamicallyAccessedMembers(DynamicallyAccessedPublicPropertiesOrFields)] T>( + this IEnumerable source) + => MoreEnumerable. ToDataTable(source); /// /// Appends elements in the sequence as rows of a given @@ -70,8 +72,10 @@ public static DataTable ToDataTable(this IEnumerable source) /// /// This operator uses immediate execution. + [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)] public static DataTable ToDataTable(this IEnumerable source, params Expression>[] expressions) => MoreEnumerable.ToDataTable(source, expressions); + /// /// Appends elements in the sequence as rows of a given object. /// @@ -84,9 +88,12 @@ public static DataTable ToDataTable(this IEnumerable source, params Expres /// /// This operator uses immediate execution. - public static TTable ToDataTable(this IEnumerable source, TTable table) + [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)] + public static TTable + ToDataTable<[DynamicallyAccessedMembers(DynamicallyAccessedPublicPropertiesOrFields)] T, + TTable>(this IEnumerable source, TTable table) where TTable : DataTable - => MoreEnumerable.ToDataTable(source, table); + => MoreEnumerable. ToDataTable(source, table); /// /// Appends elements in the sequence as rows of a given @@ -103,6 +110,7 @@ public static TTable ToDataTable(this IEnumerable source, TTable t /// /// This operator uses immediate execution. + [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)] public static TTable ToDataTable(this IEnumerable source, TTable table, params Expression>[] expressions) where TTable : DataTable => MoreEnumerable.ToDataTable(source, table, expressions); diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 6c1c604b5..8604ca538 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -126,6 +126,7 @@ true MoreLinq Library + true key.snk true true @@ -170,9 +171,13 @@ System.Index; System.Diagnostics.CodeAnalysis.DoesNotReturnAttribute; System.Diagnostics.CodeAnalysis.DoesNotReturnIfAttribute; + System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes; + System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute; System.Diagnostics.CodeAnalysis.MaybeNullWhenAttribute; System.Diagnostics.CodeAnalysis.MemberNotNullAttribute; System.Diagnostics.CodeAnalysis.NotNullWhenAttribute; + System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute; + System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute; System.Runtime.CompilerServices.CallerArgumentExpressionAttribute; @@ -211,6 +216,10 @@ $(DefineConstants);NO_ASYNC_STREAMS;NO_BUFFERS + + $(DefineConstants);DYNAMIC_CODE_FALLBACK + + diff --git a/MoreLinq/ToDataTable.cs b/MoreLinq/ToDataTable.cs index ba2275956..1872c3d85 100644 --- a/MoreLinq/ToDataTable.cs +++ b/MoreLinq/ToDataTable.cs @@ -20,61 +20,83 @@ namespace MoreLinq using System; using System.Collections.Generic; using System.Data; + using System.Diagnostics.CodeAnalysis; using System.Linq; using System.Linq.Expressions; using System.Reflection; + using static Diagnostics; static partial class MoreEnumerable { /// - /// Appends elements in the sequence as rows of a given object. + /// Converts a sequence to a object. /// /// The type of the elements of . - /// /// The source. - /// /// - /// A or subclass representing the source. + /// A representing the source. /// /// This operator uses immediate execution. - public static TTable ToDataTable(this IEnumerable source, TTable table) - where TTable : DataTable + [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)] + public static DataTable + ToDataTable<[DynamicallyAccessedMembers(DynamicallyAccessedPublicPropertiesOrFields)] T>( + this IEnumerable source) { - return ToDataTable(source, table, []); + if (source == null) throw new ArgumentNullException(nameof(source)); + + return source.ToDataTable(new DataTable()); } /// - /// Appends elements in the sequence as rows of a given - /// object with a set of lambda expressions specifying which members (property - /// or field) of each element in the sequence will supply the column values. + /// Appends elements in the sequence as rows of a given object. /// /// The type of the elements of . + /// /// The source. - /// Expressions providing access to element members. + /// /// - /// A representing the source. + /// A or subclass representing the source. /// /// This operator uses immediate execution. - public static DataTable ToDataTable(this IEnumerable source, params Expression>[] expressions) + [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)] + public static TTable + ToDataTable<[DynamicallyAccessedMembers(DynamicallyAccessedPublicPropertiesOrFields)] T, + TTable>(this IEnumerable source, TTable table) + where TTable : DataTable { - return ToDataTable(source, new DataTable(), expressions); + if (source == null) throw new ArgumentNullException(nameof(source)); + if (table == null) throw new ArgumentNullException(nameof(table)); + + const BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance; + + var members = typeof(T).GetProperties(bindingFlags) + .Where(p => p.CanRead && p.GetIndexParameters().Length == 0) + .Cast() + .Concat(typeof(T).GetFields(bindingFlags)) + .ToArray(); + + return ToDataTable(source, table, members); } /// - /// Converts a sequence to a object. + /// Appends elements in the sequence as rows of a given + /// object with a set of lambda expressions specifying which members (property + /// or field) of each element in the sequence will supply the column values. /// /// The type of the elements of . /// The source. + /// Expressions providing access to element members. /// /// A representing the source. /// /// This operator uses immediate execution. - public static DataTable ToDataTable(this IEnumerable source) + [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)] + public static DataTable ToDataTable(this IEnumerable source, params Expression>[] expressions) { - return ToDataTable(source, new DataTable()); + return ToDataTable(source, new DataTable(), expressions); } /// @@ -92,6 +114,7 @@ public static DataTable ToDataTable(this IEnumerable source) /// /// This operator uses immediate execution. + [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)] public static TTable ToDataTable(this IEnumerable source, TTable table, params Expression>[] expressions) where TTable : DataTable { @@ -99,7 +122,13 @@ public static TTable ToDataTable(this IEnumerable source, TTable t if (table == null) throw new ArgumentNullException(nameof(table)); if (expressions == null) throw new ArgumentNullException(nameof(expressions)); - var members = PrepareMemberInfos(expressions).ToArray(); + return ToDataTable(source, table, PrepareMemberInfos(expressions)); + } + + [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)] + static TTable ToDataTable(IEnumerable source, TTable table, MemberInfo[] members) + where TTable : DataTable + { var boundMembers = BuildOrBindSchema(table, members); var shredder = CreateShredder(boundMembers); @@ -127,19 +156,10 @@ public static TTable ToDataTable(this IEnumerable source, TTable t return table; } - static IEnumerable PrepareMemberInfos(ICollection>> expressions) + static MemberInfo[] PrepareMemberInfos(ICollection>> expressions) { - // - // If no lambda expressions supplied then reflect them off the source element type. - // - if (expressions.Count == 0) - { - return from m in typeof(T).GetMembers(BindingFlags.Public | BindingFlags.Instance) - where m.MemberType == MemberTypes.Field - || m is PropertyInfo { CanRead: true } p && p.GetIndexParameters().Length == 0 - select m; - } + return []; // // Ensure none of the expressions is null. @@ -149,7 +169,7 @@ static IEnumerable PrepareMemberInfos(ICollection + [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)] static MemberInfo?[] BuildOrBindSchema(DataTable table, MemberInfo[] members) { // @@ -224,8 +245,48 @@ var type when Nullable.GetUnderlyingType(type) is { } ut => ut, }; } - static Func CreateShredder(MemberInfo?[] members) + [UnconditionalSuppressMessage("Aot", "IL3050:RequiresDynamicCode", + Justification = "Falls back to reflection-based member access at run-time if the CLR " + + "version does not support dynamic code generation.")] + static Func CreateShredder(MemberInfo?[] members) { +#if DYNAMIC_CODE_FALLBACK + + // + // If the runtime does not support dynamic code generation, then + // fall back to reflection-based member access at run-time. + // + // See also: https://github.com/dotnet/runtime/issues/17973#issuecomment-1330799386 + // + + if (!System.Runtime.CompilerServices.RuntimeFeature.IsDynamicCodeSupported) + { + return obj => + { + var values = new object?[members.Length]; + + for (var i = 0; i < members.Length; i++) + { + var member = members[i]; + values[i] = member switch + { + null => null, + PropertyInfo pi => pi.GetValue(obj), + FieldInfo fi => fi.GetValue(obj), + _ => throw new UnreachableException(), + }; + } + + return values; + }; + } +#endif + + // + // Otherwise compile a lambda expression that will extract the + // values of the specified members from an object instance. + // + var parameter = Expression.Parameter(typeof(T), "e"); // @@ -240,7 +301,7 @@ static Func CreateShredder(MemberInfo?[] members) var array = Expression.NewArrayInit(typeof(object), initializers); - var lambda = Expression.Lambda>(array, parameter); + var lambda = Expression.Lambda>(array, parameter); return lambda.Compile(); @@ -251,4 +312,27 @@ UnaryExpression CreateMemberAccessor(MemberInfo member) } } } + + namespace Extensions + { + partial class ToDataTableExtension + { + internal const DynamicallyAccessedMemberTypes DynamicallyAccessedPublicPropertiesOrFields + = DynamicallyAccessedMemberTypes.PublicProperties | + DynamicallyAccessedMemberTypes.PublicFields; + + internal const string RequiresUnreferencedCodeMessage = + "This method uses reflection to access public properties and fields of the source " + + "type, and in turn the types of those properties and fields. That latter could be " + + "problematic and require root descriptors for some custom and complex types " + + "(although columns usually store simple, scalar types). For more, see: " + + "https://learn.microsoft.com/en-us/dotnet/core/deploying/trimming/trimming-options#root-descriptors"; + } + } + + file static class Diagnostics + { + public const DynamicallyAccessedMemberTypes DynamicallyAccessedPublicPropertiesOrFields = MoreLinq.Extensions.ToDataTableExtension.DynamicallyAccessedPublicPropertiesOrFields; + public const string RequiresUnreferencedCodeMessage = MoreLinq.Extensions.ToDataTableExtension.RequiresUnreferencedCodeMessage; + } } diff --git a/test.cmd b/test.cmd index a6d28730d..209719ca3 100644 --- a/test.cmd +++ b/test.cmd @@ -7,6 +7,10 @@ popd & exit /b %ERRORLEVEL% setlocal if not defined SKIP_TEST_BUILD set SKIP_TEST_BUILD=false if %SKIP_TEST_BUILD%==false call build || exit /b 1 +if not "%~1"=="aot" goto :test-all +call :test-aot +exit /b %ERRORLEVEL% +:test-all call :clean ^ && call :test net8.0 Debug ^ && call :test net8.0 Release ^ @@ -14,7 +18,8 @@ call :clean ^ && call :test net6.0 Release ^ && call :test net471 Debug ^ && call :test net471 Release ^ - && call :report-cover + && call :report-cover ^ + && call :test-aot exit /b %ERRORLEVEL% :clean @@ -51,3 +56,17 @@ dotnet reportgenerator -reports:coverage-*.opencover.xml ^ -targetdir:reports ^ && type reports\Summary.txt exit /b %ERRORLEVEL% + +:test-aot +setlocal +cd MoreLinq.Test.Aot +dotnet publish +if not ERRORLEVEL==0 exit /b %ERRORLEVEL% +set AOT_TEST_PUBLISH_DIR= +for /f %%d in ('dir /ad /s /b publish') do if not defined AOT_TEST_PUBLISH_DIR set AOT_TEST_PUBLISH_DIR=%%~d +if not defined AOT_TEST_PUBLISH_DIR ( + echo>&2 Published binary directory not found! + exit /b 1 +) +"%AOT_TEST_PUBLISH_DIR%\MoreLinq.Test.Aot.exe" +exit /b %ERRORLEVEL% diff --git a/test.sh b/test.sh index 9bd9806a0..8427d1849 100755 --- a/test.sh +++ b/test.sh @@ -31,3 +31,5 @@ else mono MoreLinq.Test/bin/$c/net471/MoreLinq.Test.exe done fi +dotnet publish MoreLinq.Test.Aot +"$(find MoreLinq.Test.Aot -type d -name publish)/MoreLinq.Test.Aot" From 9c130ff557657f26132c6f03961b0454029fecf7 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sat, 6 Jul 2024 18:35:28 +0200 Subject: [PATCH 152/157] Bump version to 4.3 --- MoreLinq/MoreLinq.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 8604ca538..8264eee51 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -119,7 +119,7 @@ $([System.Text.RegularExpressions.Regex]::Replace($(Copyright), `\s+`, ` `).Trim()) MoreLINQ en-US - 4.2.0 + 4.3.0 MoreLINQ Developers. netstandard2.0;netstandard2.1;net6.0;net8.0 portable From 6515ba022a5388211891eadd557b24922dd05d3d Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Wed, 18 Sep 2024 20:29:37 +0200 Subject: [PATCH 153/157] Bump version to 4.3.1 --- MoreLinq/MoreLinq.csproj | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index 8264eee51..ebcfe6da4 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -119,7 +119,7 @@ $([System.Text.RegularExpressions.Regex]::Replace($(Copyright), `\s+`, ` `).Trim()) MoreLINQ en-US - 4.3.0 + 4.3.1 MoreLINQ Developers. netstandard2.0;netstandard2.1;net6.0;net8.0 portable From d5187e43f86ffdb3dfc7e78b6bf36f237a40a9ae Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Wed, 18 Sep 2024 21:55:12 +0200 Subject: [PATCH 154/157] Update all tools to their latest versions --- .config/dotnet-tools.json | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json index 890982194..cb5fca77b 100644 --- a/.config/dotnet-tools.json +++ b/.config/dotnet-tools.json @@ -3,28 +3,32 @@ "isRoot": true, "tools": { "dotnet-t4": { - "version": "2.3.0", + "version": "3.0.0", "commands": [ "t4" - ] + ], + "rollForward": false }, "dotnet-reportgenerator-globaltool": { - "version": "5.1.11", + "version": "5.3.9", "commands": [ "reportgenerator" - ] + ], + "rollForward": false }, "meziantou.framework.nugetpackagevalidation.tool": { - "version": "1.0.14", + "version": "1.0.16", "commands": [ "meziantou.validate-nuget-package" - ] + ], + "rollForward": false }, "powershell": { - "version": "7.4.0", + "version": "7.4.5", "commands": [ "pwsh" - ] + ], + "rollForward": false } } } From 088df950da8f5539343147d6da27a122bf8e0ccb Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Thu, 19 Sep 2024 16:54:37 +0200 Subject: [PATCH 155/157] Update .NET SDK to 8.0.400, including dependencies This is a squashed commit of PR #1074 that closes #1073. --- MoreLinq.Test.Aot/MoreLinq.Test.Aot.csproj | 16 ++++++++-------- MoreLinq.Test.Aot/ToDataTableTest.cs | 2 +- MoreLinq.Test/MoreLinq.Test.csproj | 12 ++++++------ MoreLinq/MoreLinq.csproj | 3 ++- bld/ExtensionsGenerator/.editorconfig | 2 ++ .../MoreLinq.ExtensionsGenerator.csproj | 2 +- global.json | 2 +- 7 files changed, 21 insertions(+), 18 deletions(-) create mode 100644 bld/ExtensionsGenerator/.editorconfig diff --git a/MoreLinq.Test.Aot/MoreLinq.Test.Aot.csproj b/MoreLinq.Test.Aot/MoreLinq.Test.Aot.csproj index 9453f8dc7..219cc362d 100644 --- a/MoreLinq.Test.Aot/MoreLinq.Test.Aot.csproj +++ b/MoreLinq.Test.Aot/MoreLinq.Test.Aot.csproj @@ -8,14 +8,14 @@ - - - - - - - - + + + + + + + + all runtime; build; native; contentfiles; analyzers; buildtransitive diff --git a/MoreLinq.Test.Aot/ToDataTableTest.cs b/MoreLinq.Test.Aot/ToDataTableTest.cs index 163c76598..c0be620f1 100644 --- a/MoreLinq.Test.Aot/ToDataTableTest.cs +++ b/MoreLinq.Test.Aot/ToDataTableTest.cs @@ -15,7 +15,7 @@ // limitations under the License. #endregion -namespace MoreLinq.Test +namespace MoreLinq.Test.Aot { using System; using System.Collections; diff --git a/MoreLinq.Test/MoreLinq.Test.csproj b/MoreLinq.Test/MoreLinq.Test.csproj index 5defc11f4..5e6a4cdce 100644 --- a/MoreLinq.Test/MoreLinq.Test.csproj +++ b/MoreLinq.Test/MoreLinq.Test.csproj @@ -26,20 +26,20 @@ runtime; build; native; contentfiles; analyzers all - - + + all runtime; build; native; contentfiles; analyzers; buildtransitive - + all runtime; build; native; contentfiles; analyzers; buildtransitive - + - - + + diff --git a/MoreLinq/MoreLinq.csproj b/MoreLinq/MoreLinq.csproj index ebcfe6da4..1ec1d5123 100644 --- a/MoreLinq/MoreLinq.csproj +++ b/MoreLinq/MoreLinq.csproj @@ -126,6 +126,7 @@ true MoreLinq Library + true true key.snk true @@ -150,7 +151,7 @@ - + runtime; build; native; contentfiles; analyzers; buildtransitive all diff --git a/bld/ExtensionsGenerator/.editorconfig b/bld/ExtensionsGenerator/.editorconfig new file mode 100644 index 000000000..72716eada --- /dev/null +++ b/bld/ExtensionsGenerator/.editorconfig @@ -0,0 +1,2 @@ +[ProgramArguments.cs] +dotnet_analyzer_diagnostic.category-Style.severity = suggestion diff --git a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj index a8c8964b0..665931e3e 100644 --- a/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj +++ b/bld/ExtensionsGenerator/MoreLinq.ExtensionsGenerator.csproj @@ -6,7 +6,7 @@ - + diff --git a/global.json b/global.json index d031a7632..db09cbbe9 100644 --- a/global.json +++ b/global.json @@ -1,6 +1,6 @@ { "sdk": { - "version": "8.0.200", + "version": "8.0.400", "rollForward": "latestPatch" } } From ede868e6a72b61348dee7229691307ab966451e9 Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 22 Sep 2024 20:37:57 +0200 Subject: [PATCH 156/157] Drop CI build matrix & testing on macOS images --- .github/workflows/build.yml | 6 +++--- appveyor.yml | 7 ------- 2 files changed, 3 insertions(+), 10 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index d7edc5aab..39d7f54d1 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -26,7 +26,7 @@ jobs: runs-on: ${{ matrix.os }} strategy: matrix: - os: [windows-2022, ubuntu-22.04, macos-11] + os: [windows-2022, ubuntu-22.04] steps: @@ -81,7 +81,7 @@ jobs: if: runner.os == 'Windows' run: call pack.cmd - - name: Build & Pack (Linux/macOS) + - name: Build & Pack (Linux) if: runner.os != 'Windows' run: ./pack.sh @@ -109,7 +109,7 @@ jobs: if: runner.os == 'Windows' run: call test.cmd - - name: Test (Linux/macOS) + - name: Test (Linux) if: runner.os != 'Windows' run: ./test.sh diff --git a/appveyor.yml b/appveyor.yml index 646a17b24..479a8e45c 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -2,7 +2,6 @@ version: '{build}' image: - Visual Studio 2022 - Ubuntu1804 -- macos-bigsur environment: DOTNET_CLI_TELEMETRY_OPTOUT: true DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true @@ -38,12 +37,6 @@ for: - image: Ubuntu1804 environment: IMAGE_NAME: ubuntu-18.04 -- - matrix: - only: - - image: macos-bigsur - environment: - IMAGE_NAME: macos install: - npm install -g eclint - git rm .editorconfig From 5dc9e18a2ef00fb0eb879f5506ae09857a27012b Mon Sep 17 00:00:00 2001 From: Atif Aziz Date: Sun, 22 Sep 2024 22:17:15 +0200 Subject: [PATCH 157/157] Drop conditional testing on Mono (#1081) --- MoreLinq.Test/TransposeTest.cs | 21 ++++----------------- test.sh | 8 -------- 2 files changed, 4 insertions(+), 25 deletions(-) diff --git a/MoreLinq.Test/TransposeTest.cs b/MoreLinq.Test/TransposeTest.cs index 2e1cf417d..0394c4a9b 100644 --- a/MoreLinq.Test/TransposeTest.cs +++ b/MoreLinq.Test/TransposeTest.cs @@ -58,7 +58,7 @@ public void TransposeWithRowsOfSameLength() using var row3 = TestingSequence.Of(30, 31, 32, 33); using var matrix = TestingSequence.Of(row1, row2, row3); - AssertMatrix(expectations, matrix.Transpose()); + Assert.That(matrix.Transpose(), Is.EqualTo(expectations)); } [Test] @@ -77,7 +77,7 @@ public void TransposeWithRowsOfDifferentLengths() using var row4 = TestingSequence.Of(30, 31, 32); using var matrix = TestingSequence.Of(row1, row2, row3, row4); - AssertMatrix(expectations, matrix.Transpose()); + Assert.That(matrix.Transpose(), Is.EqualTo(expectations)); } [Test] @@ -116,7 +116,7 @@ public void TransposeWithAllRowsAsInfiniteSequences() [32, 243, 3125] }; - AssertMatrix(expectations, result); + Assert.That(result, Is.EqualTo(expectations)); } [Test] @@ -139,7 +139,7 @@ public void TransposeWithSomeRowsAsInfiniteSequences() [32, 3125] }; - AssertMatrix(expectations, result); + Assert.That(result, Is.EqualTo(expectations)); } [Test] @@ -207,18 +207,5 @@ static bool IsPrime(int number) return true; } - - static void AssertMatrix(IEnumerable> expectation, IEnumerable> result) - { - // necessary because NUnitLite 3.6.1 (.NET 4.5) for Mono don't assert nested enumerables - - var resultList = result.ToList(); - var expectationList = expectation.ToList(); - - Assert.That(resultList.Count, Is.EqualTo(expectationList.Count)); - - expectationList.Zip(resultList, ValueTuple.Create) - .ForEach(t => t.Item1.AssertSequenceEqual(t.Item2)); - } } } diff --git a/test.sh b/test.sh index 8427d1849..5287da315 100755 --- a/test.sh +++ b/test.sh @@ -23,13 +23,5 @@ dotnet reportgenerator -reports:MoreLinq.Test/TestResults/coverage-*.opencover.x -reporttypes:Html\;TextSummary \ -targetdir:MoreLinq.Test/TestResults/reports cat MoreLinq.Test/TestResults/reports/Summary.txt -if [[ -z `which mono 2>/dev/null` ]]; then - echo>&2 NOTE! Mono does not appear to be installed so unit tests - echo>&2 against the Mono runtime will be skipped. -else - for c in $configs; do - mono MoreLinq.Test/bin/$c/net471/MoreLinq.Test.exe - done -fi dotnet publish MoreLinq.Test.Aot "$(find MoreLinq.Test.Aot -type d -name publish)/MoreLinq.Test.Aot"