From 9ca3cf0cc9311e0a7f72536862e4041785d7c621 Mon Sep 17 00:00:00 2001 From: Thomas Bruderer Date: Fri, 30 Oct 2026 09:13:22 +0100 Subject: [PATCH] Funcky.Async 2.0: build on System.Linq.AsyncEnumerable and remove the Await operators Funcky.Async drops System.Linq.Async 5/6 and compiles Funcky's async sources against System.Linq.AsyncEnumerable, the package that is the .NET 10 base class library's IAsyncEnumerable LINQ, so the sources need no conditional compilation any more: the SystemLinqAsyncAdapter, the AsyncGrouping type, the Chunk(size) shim and every SYSTEM_LINQ_ASYNC branch are gone, and AdjacentGroupBy returns IGrouping on every framework. System.Linq.Async 7 was not chosen because it also brings System.Interactive.Async along, whose Merge on a sequence of sequences silently wins over Funcky's sorted Merge. The twelve lazy Await/AwaitWithCancellation operators and the AwaitAsync / AwaitWithCancellationAsync overloads of the eight terminal aggregations, obsolete since 3.8.0, are removed from the net10.0 asset of Funcky and from Funcky.Async together with their tests; the PublicAPI files record the removals and the changed AdjacentGroupBy signatures. The code fix stays as the migration aid and now also fires on the compile error CS1061 a removed name leaves behind, recognizing the call by its name, a receiver the replacement accepts and the shape of the arguments. Closes #925 Closes #981 Co-Authored-By: Claude Fable 5.1 --- .github/workflows/build.yml | 4 +- Directory.Packages.props | 15 +- Documentation/src/async.md | 31 +- .../AsyncEnumerableAwaitOperatorCodeFix.cs | 134 +++++++- ...umerableAwaitOperatorRemovedCodeFixTest.cs | 285 ++++++++++++++++ Funcky.Async.Test/Funcky.Async.Test.csproj | 17 +- .../SystemLinqAsyncTestAdapter.cs | 11 - Funcky.Async/CompatibilitySuppressions.xml | 107 +----- .../AsyncGrouping.cs | 31 -- Funcky.Async/Funcky.Async.csproj | 21 +- .../Internal/SystemLinqAsyncAdapter.cs | 35 -- .../PublicAPI/common/PublicAPI.Unshipped.txt | 134 ++++++++ .../PublicAPI/net10.0/PublicAPI.Unshipped.txt | 116 +++++++ .../PublicAPI/net11.0/PublicAPI.Unshipped.txt | 116 +++++++ .../netstandard2.0/PublicAPI.Unshipped.txt | 134 ++++++++ Funcky.Async/package.md | 5 + Funcky.Test/AsyncGenerator.cs | 8 - .../AdjacentGroupByTest.cs | 16 - .../ArgumentValidationTest.cs | 29 -- .../AverageOrNoneTest.cs | 26 -- .../AsyncEnumerableExtensions/ChunkTest.cs | 109 ------ .../AsyncEnumerableExtensions/InspectTest.cs | 35 -- .../MaxOrNoneTest.cs | 31 -- .../MinOrNoneTest.cs | 31 -- .../PartitionTest.cs | 17 - .../AdjacentGroupBy.ValueTask.cs | 68 +++- .../AdjacentGroupBy.cs | 21 -- .../AdjacentGroupByAwait.cs | 229 ------------- .../AdjacentGroupByAwaitWithCancellation.cs | 239 -------------- .../AverageOrNoneAwait.cs | 312 ------------------ .../AsyncEnumerableExtensions/Chunk.cs | 33 -- .../AsyncEnumerableExtensions/FirstOrNone.cs | 12 - .../AsyncEnumerableExtensions/Inspect.cs | 34 -- .../AsyncEnumerableExtensions/LastOrNone.cs | 12 - .../AsyncEnumerableExtensions/MaxOrNone.cs | 46 --- .../AsyncEnumerableExtensions/MinOrNone.cs | 41 --- .../AsyncEnumerableExtensions/None.cs | 12 - .../AsyncEnumerableExtensions/Partition.cs | 34 -- .../AsyncEnumerableExtensions/Scan.cs | 68 ---- .../AsyncEnumerableExtensions/SingleOrNone.cs | 12 - .../AsyncEnumerableExtensions/WhereSelect.cs | 59 ---- .../PublicAPI/net10.0/PublicAPI.Unshipped.txt | 116 +++++++ .../PublicAPI/net11.0/PublicAPI.Unshipped.txt | 116 +++++++ changelog.md | 17 + 44 files changed, 1257 insertions(+), 1722 deletions(-) create mode 100644 Funcky.Analyzers/Funcky.Analyzers.Test/AsyncEnumerableAwaitOperatorRemovedCodeFixTest.cs delete mode 100644 Funcky.Async.Test/TestUtilities/SystemLinqAsyncTestAdapter.cs delete mode 100644 Funcky.Async/Extensions/AsyncEnumerableExtensions/AsyncGrouping.cs delete mode 100644 Funcky.Async/Internal/SystemLinqAsyncAdapter.cs delete mode 100644 Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupByAwait.cs delete mode 100644 Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupByAwaitWithCancellation.cs delete mode 100644 Funcky/Extensions/AsyncEnumerableExtensions/AverageOrNoneAwait.cs diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 6ae2a498b..d3f70e4b6 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -15,9 +15,9 @@ jobs: strategy: matrix: os: [ ubuntu-latest, windows-latest ] - systemLinqAsync: [ '5.0.0', '6.0.3' ] + systemLinqAsyncEnumerable: [ '10.0.6', '10.0.14' ] env: - SystemLinqAsyncVersion: ${{matrix.systemLinqAsync}} + SystemLinqAsyncEnumerableVersion: ${{matrix.systemLinqAsyncEnumerable}} runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v4 diff --git a/Directory.Packages.props b/Directory.Packages.props index e9011185f..04f62097d 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -11,11 +11,16 @@ - - + + diff --git a/Documentation/src/async.md b/Documentation/src/async.md index 846bc206b..8332c69f1 100644 --- a/Documentation/src/async.md +++ b/Documentation/src/async.md @@ -12,18 +12,19 @@ The asynchronous APIs have two homes, and which one you use depends only on your is in the base class library since .NET 10, so Funcky can build on it without an extra dependency. You need no second package. * **Older frameworks** (`netstandard2.0` up to .NET 9): they are in the `Funcky.Async` package, which compiles the same - sources against [System.Linq.Async](https://www.nuget.org/packages/System.Linq.Async) (versions 5 and 6). + sources against [System.Linq.AsyncEnumerable](https://www.nuget.org/packages/System.Linq.AsyncEnumerable), the very + library that is part of .NET 10, so the operators have the same shapes on both sides. A project that still references + [System.Linq.Async](https://www.nuget.org/packages/System.Linq.Async) 5 or 6 gets a type clash (CS0433) on + `System.Linq.AsyncEnumerable`; upgrade that reference to System.Linq.Async 7, which forwards to the same package, or + drop it. Funcky.Async 1.x is the line for projects that are stuck on System.Linq.Async 5 or 6; it receives no new + features. The `net10.0` and `net11.0` assets of `Funcky.Async` contain nothing but type forwards to `Funcky`. A project that referenced `Funcky.Async` on .NET 8 and then retargets to .NET 10 therefore keeps the package reference working, and can drop -it whenever convenient. The forwards do not make the two sides source compatible, though: where the base class -library already provides an operator, Funcky defers to it, and two of them differ from the `Funcky.Async` shape. - -* `AdjacentGroupBy` returns `IAsyncEnumerable>` in `Funcky.Async`, since System.Linq.Async - has no synchronous groupings, and `IAsyncEnumerable>` on .NET 10. Code that treats a group as a - sequence, `await grouping.CountAsync()` for example, becomes `grouping.Count()` after retargeting. -* `Chunk(size)` without a result selector is the base class library's on .NET 10 and yields `T[]` instead of - `IReadOnlyList`. The overloads with a result selector are Funcky's on both sides and keep `IReadOnlyList`. +it whenever convenient. Since Funcky.Async 2.0.0 the two sides are also source compatible: `AdjacentGroupBy` returns +`IAsyncEnumerable>` everywhere, and `Chunk(size)` without a result selector is the one of +`System.Linq.AsyncEnumerable` everywhere (it yields `T[]`; the overloads with a result selector are Funcky's and keep +`IReadOnlyList`). Namespaces and type names are otherwise the same on both sides: the extension methods are in `Funcky.Extensions.AsyncEnumerableExtensions`, the constructors in `Funcky.AsyncSequence`, retrying in @@ -131,7 +132,8 @@ Before 3.8.0 Funcky used the vocabulary of System.Linq.Async, which has three na synchronous delegate, `InspectAwait` for an asynchronous one, and `InspectAwaitWithCancellation` for an asynchronous one that receives the token. The terminal aggregations followed with `FirstOrNoneAwaitAsync` and `FirstOrNoneAwaitWithCancellationAsync`. Since 3.8.0 these overloads are `[Obsolete]`, they stay a warning (CS0618) -for the whole 3.x line, and they are removed in Funcky 4.0.0 ([#981](https://github.com/polyadic/funcky/issues/981)). +for the whole 3.x line, and Funcky 4.0.0 removed them ([#981](https://github.com/polyadic/funcky/issues/981)): a call +of an old name is now the compile error CS1061, "no accessible extension method". The mapping is mechanical: @@ -147,10 +149,11 @@ its own replacement. ### Apply the code fix solution-wide -Do not do this by hand. [Funcky.Analyzers](./analyzer-rules/analyzer-rules.md) 2.1.0 ships a code fix for CS0618 on -these methods, with fix-all support. In the IDE, open the lightbulb on any of the warnings, choose the fix, and apply it -to the **solution** (the fix-all scope selector offers document, project and solution). One pass migrates every call -site. The fix: +Do not do this by hand. [Funcky.Analyzers](./analyzer-rules/analyzer-rules.md) ships a code fix for these methods, +with fix-all support: on 3.8.0 it fixes the obsoletion warning CS0618, and since Funcky.Analyzers 3.0.0 it also fixes +the compile error CS1061 that the removed names leave behind on 4.0.0, so you can upgrade first and migrate second. +In the IDE, open the lightbulb on any of the diagnostics, choose the fix, and apply it to the **solution** (the fix-all +scope selector offers document, project and solution). One pass migrates every call site. The fix: * renames `…AwaitWithCancellation` and `…AwaitWithCancellationAsync` calls and leaves the delegate alone; * renames `…Await` and `…AwaitAsync` calls and appends the discarded token parameter to every lambda argument, diff --git a/Funcky.Analyzers/Funcky.Analyzers.CodeFixes/AsyncEnumerableAwaitOperatorCodeFix.cs b/Funcky.Analyzers/Funcky.Analyzers.CodeFixes/AsyncEnumerableAwaitOperatorCodeFix.cs index 8a36151de..e15b384e2 100644 --- a/Funcky.Analyzers/Funcky.Analyzers.CodeFixes/AsyncEnumerableAwaitOperatorCodeFix.cs +++ b/Funcky.Analyzers/Funcky.Analyzers.CodeFixes/AsyncEnumerableAwaitOperatorCodeFix.cs @@ -13,11 +13,14 @@ namespace Funcky.Analyzers; /// -/// Offers a fix for the obsoletion warning CS0618 on the …Await and …AwaitWithCancellation operators of -/// AsyncEnumerableExtensions, which the single-name overloads with a (…, cancellationToken) delegate replace: -/// xs.FooAwaitWithCancellation((x, ct) => …) becomes xs.Foo((x, ct) => …), and xs.FooAwait(x => …) -/// becomes xs.Foo((x, _) => …), with the ignored token parameter added to every delegate argument. -/// The terminal …AwaitAsync and …AwaitWithCancellationAsync aggregations map to …Async the same way. +/// Replaces a call of the …Await and …AwaitWithCancellation operators of AsyncEnumerableExtensions +/// with the single-name overload that takes a (…, cancellationToken) delegate: xs.FooAwaitWithCancellation((x, ct) => …) +/// becomes xs.Foo((x, ct) => …), and xs.FooAwait(x => …) becomes xs.Foo((x, _) => …), with the ignored +/// token parameter added to every delegate argument. The terminal …AwaitAsync and …AwaitWithCancellationAsync +/// aggregations map to …Async the same way. The fix is offered on the obsoletion warning CS0618 (Funcky 3.8.0) and on +/// the compile error CS1061 that a call of a removed operator reports (Funcky 4.0.0), so a project can upgrade first and +/// rewrite after. Without a bound method the fix recognizes the call by its name, by the receiver being one the replacement +/// accepts, and tells the delegate arguments apart by their syntax and types. /// [Shared] [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(AsyncEnumerableAwaitOperatorCodeFix))] @@ -26,6 +29,9 @@ public sealed class AsyncEnumerableAwaitOperatorCodeFix : CodeFixProvider /// The compiler diagnostic reported on the use of a member marked [Obsolete] with a message. private const string ObsoleteMemberDiagnosticId = "CS0618"; + /// The compiler diagnostic reported on a member or extension method a type does not have, which a call of a removed operator is. + private const string MissingMemberDiagnosticId = "CS1061"; + private const string AwaitSuffix = "Await"; private const string AwaitWithCancellationSuffix = "AwaitWithCancellation"; @@ -36,7 +42,7 @@ public sealed class AsyncEnumerableAwaitOperatorCodeFix : CodeFixProvider private static readonly string[] CandidateParameterNames = ["x", "y", "z", "w"]; - public override ImmutableArray FixableDiagnosticIds => ImmutableArray.Create(ObsoleteMemberDiagnosticId); + public override ImmutableArray FixableDiagnosticIds => ImmutableArray.Create(ObsoleteMemberDiagnosticId, MissingMemberDiagnosticId); public override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer; @@ -52,22 +58,60 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) foreach (var diagnostic in context.Diagnostics) { - // The warning spans the whole call; one with a smaller span belongs to an obsolete member inside an argument. - if (root.FindInvocationExpression(diagnostic.Location.SourceSpan) is { } invocation - && invocation.Span == diagnostic.Location.SourceSpan - && GetMethodName(invocation) is { } name - && semanticModel.GetOperation(invocation, context.CancellationToken) is IInvocationOperation { TargetMethod: var method } operation - && IsDeclaredIn(method, extensionsType) - && Replacement.TryCreate(method.Name) is { } replacement - && HasMember(extensionsType, replacement.Name) - && DelegateArguments(operation, invocation) is { } delegateArguments - && (!replacement.AddsTokenParameter || delegateArguments.All(argument => IsRewritable(argument.Syntax)))) + if (FindCall(root, semanticModel, diagnostic, extensionsType, context.CancellationToken) is { } call + && (!call.Replacement.AddsTokenParameter || call.DelegateArguments.All(argument => IsRewritable(argument.Syntax)))) { - context.RegisterCodeFix(new RenameOperatorCodeFixAction(context.Document, invocation, name, replacement, delegateArguments), diagnostic); + context.RegisterCodeFix(new RenameOperatorCodeFixAction(context.Document, call.Invocation, call.Name, call.Replacement, call.DelegateArguments), diagnostic); } } } + private static ObsoleteCall? FindCall(SyntaxNode root, SemanticModel semanticModel, Diagnostic diagnostic, INamedTypeSymbol extensionsType, CancellationToken cancellationToken) + => diagnostic.Id switch + { + ObsoleteMemberDiagnosticId => FindObsoleteCall(root, semanticModel, diagnostic, extensionsType, cancellationToken), + MissingMemberDiagnosticId => FindRemovedCall(root, semanticModel, diagnostic, extensionsType, cancellationToken), + _ => null, + }; + + // The warning spans the whole call; one with a smaller span belongs to an obsolete member inside an argument. + private static ObsoleteCall? FindObsoleteCall(SyntaxNode root, SemanticModel semanticModel, Diagnostic diagnostic, INamedTypeSymbol extensionsType, CancellationToken cancellationToken) + => root.FindInvocationExpression(diagnostic.Location.SourceSpan) is { } invocation + && invocation.Span == diagnostic.Location.SourceSpan + && GetMethodName(invocation) is { } name + && semanticModel.GetOperation(invocation, cancellationToken) is IInvocationOperation { TargetMethod: var method } operation + && IsDeclaredIn(method, extensionsType) + && Replacement.TryCreate(method.Name) is { } replacement + && HasMember(extensionsType, replacement.Name) + && DelegateArguments(operation, invocation) is { } delegateArguments + ? new ObsoleteCall(invocation, name, replacement, delegateArguments) + : null; + + // The error spans the member name. Nothing binds the name to Funcky any more, so the call counts when the receiver is a type the + // replacement accepts and no argument is named (the delegates are found by position). + private static ObsoleteCall? FindRemovedCall(SyntaxNode root, SemanticModel semanticModel, Diagnostic diagnostic, INamedTypeSymbol extensionsType, CancellationToken cancellationToken) + => root.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true) is SimpleNameSyntax { Parent: MemberAccessExpressionSyntax { Expression: var receiver, Parent: InvocationExpressionSyntax invocation } memberAccess } name + && memberAccess.Name == name + && Replacement.TryCreate(name.Identifier.ValueText) is { } replacement + && semanticModel.GetTypeInfo(receiver, cancellationToken).Type is { TypeKind: not TypeKind.Error } receiverType + && AcceptsReceiver(extensionsType, replacement.Name, receiverType) + && invocation.ArgumentList.Arguments.All(argument => argument.NameColon is null) + && DelegateArguments(invocation, semanticModel, cancellationToken) is { } delegateArguments + ? new ObsoleteCall(invocation, name, replacement, delegateArguments) + : null; + + // An extension member is lowered to a static method with the receiver as its first parameter, like a classic extension method. + private static bool AcceptsReceiver(INamedTypeSymbol extensionsType, string name, ITypeSymbol receiverType) + => extensionsType.GetMembers(name) + .OfType() + .Any(method => method is { IsStatic: true, Parameters: [{ Type: var parameterType }, ..] } && IsOrImplements(receiverType, parameterType)); + + private static bool IsOrImplements(ITypeSymbol type, ITypeSymbol definition) + => HasSameDefinition(type, definition) || type.AllInterfaces.Any(implemented => HasSameDefinition(implemented, definition)); + + private static bool HasSameDefinition(ITypeSymbol type, ITypeSymbol other) + => SymbolEqualityComparer.Default.Equals(type.OriginalDefinition, other.OriginalDefinition); + private static SimpleNameSyntax? GetMethodName(InvocationExpressionSyntax invocation) => invocation.Expression switch { @@ -107,6 +151,59 @@ private static bool HasMember(INamedTypeSymbol type, string name) return builder.ToImmutable(); } + /// The delegate arguments of an unbound call, told apart by their syntax and types; when an argument + /// cannot be classified. + private static ImmutableArray? DelegateArguments(InvocationExpressionSyntax invocation, SemanticModel semanticModel, CancellationToken cancellationToken) + { + var builder = ImmutableArray.CreateBuilder(); + + foreach (var argument in invocation.ArgumentList.Arguments) + { + switch (DelegateArity(argument, semanticModel, cancellationToken)) + { + case null: + return null; + case { } arity and >= 0: + builder.Add(new DelegateArgument(argument, arity)); + break; + } + } + + return builder.ToImmutable(); + } + + // The arity of a delegate argument, -1 for an argument of another type, null when neither can be told. + private static int? DelegateArity(ArgumentSyntax argument, SemanticModel semanticModel, CancellationToken cancellationToken) + { + var expression = Unparenthesize(argument.Expression); + + return expression switch + { + SimpleLambdaExpressionSyntax => 1, + ParenthesizedLambdaExpressionSyntax lambda => lambda.ParameterList.Parameters.Count, + AnonymousMethodExpressionSyntax anonymousMethod => anonymousMethod.ParameterList?.Parameters.Count ?? 0, + _ => semanticModel.GetTypeInfo(expression, cancellationToken).Type switch + { + INamedTypeSymbol { TypeKind: TypeKind.Delegate, DelegateInvokeMethod: { } invoke } => invoke.Parameters.Length, + { TypeKind: not TypeKind.Error } => -1, + _ => MethodGroupArity(expression, semanticModel, cancellationToken), + }, + }; + } + + // A method group has no type of its own; its overloads agree on the arity in the cases the fix cares about. + private static int? MethodGroupArity(ExpressionSyntax expression, SemanticModel semanticModel, CancellationToken cancellationToken) + { + var symbolInfo = semanticModel.GetSymbolInfo(expression, cancellationToken); + var arities = (symbolInfo.Symbol is null ? symbolInfo.CandidateSymbols : ImmutableArray.Create(symbolInfo.Symbol)) + .OfType() + .Select(method => method.Parameters.Length) + .Distinct() + .ToArray(); + + return arities is [var arity] ? arity : null; + } + // The operation's syntax is the argument, or the bare expression when parentheses surround it, which the operation tree skips. private static ArgumentSyntax? ArgumentSyntax(IArgumentOperation argument, InvocationExpressionSyntax invocation) => argument.Syntax.FirstAncestorOrSelf() is { } syntax && syntax.Parent == invocation.ArgumentList @@ -144,6 +241,9 @@ private static ImmutableHashSet IdentifiersIn(SyntaxNode node) private sealed record DelegateArgument(ArgumentSyntax Syntax, int Arity); + /// A call of an old operator name and what to turn it into. + private sealed record ObsoleteCall(InvocationExpressionSyntax Invocation, SimpleNameSyntax Name, Replacement Replacement, ImmutableArray DelegateArguments); + private sealed record Replacement(string Name, bool AddsTokenParameter) { // Lazy operators: FooAwait → Foo, FooAwaitWithCancellation → Foo. Terminal aggregations: FooAwaitAsync → FooAsync, diff --git a/Funcky.Analyzers/Funcky.Analyzers.Test/AsyncEnumerableAwaitOperatorRemovedCodeFixTest.cs b/Funcky.Analyzers/Funcky.Analyzers.Test/AsyncEnumerableAwaitOperatorRemovedCodeFixTest.cs new file mode 100644 index 000000000..6b358b4c5 --- /dev/null +++ b/Funcky.Analyzers/Funcky.Analyzers.Test/AsyncEnumerableAwaitOperatorRemovedCodeFixTest.cs @@ -0,0 +1,285 @@ +using Microsoft.CodeAnalysis.Testing; +using Xunit; +using VerifyCS = Funcky.Analyzers.Test.CSharpCodeFixVerifier; + +namespace Funcky.Analyzers.Test; + +/// The fix on the compile error CS1061 that a call of an …Await operator reports once the operator is gone (Funcky 4.0.0). +/// Nothing binds the name to Funcky there, so the fix goes by the name, the receiver and the shape of the arguments. +public sealed class AsyncEnumerableAwaitOperatorRemovedCodeFixTest +{ + private const string MissingXmlComment = "CS1591"; + + // A stand-in for Funcky.Async 2.0 and the net10.0 asset of Funcky 4.0: only the replacements are left. + // language=csharp + private const string StubCode = + """ + namespace Funcky.Extensions + { + using System; + using System.Threading; + using System.Threading.Tasks; + + public sealed class AsyncSource + { + } + + public static class AsyncEnumerableExtensions + { + public static AsyncSource Inspect(this AsyncSource source, Action inspector) => source; + + public static AsyncSource Inspect(this AsyncSource source, Func inspector) => source; + + public static AsyncSource ExclusiveScan(this AsyncSource source, TAccumulate seed, Func> accumulator) => default!; + + public static AsyncSource AdjacentGroupBy(this AsyncSource source, Func> keySelector, Func> resultSelector) => default!; + + public static Task FirstOrNoneAsync(this AsyncSource source, Func predicate, CancellationToken cancellationToken = default) => default!; + + public static Task FirstOrNoneAsync(this AsyncSource source, Func> predicate, CancellationToken cancellationToken = default) => default!; + + public static Task PartitionAsync(this AsyncSource source, Func> predicate, Func> resultSelector, CancellationToken cancellationToken = default) => default!; + } + } + """; + + [Fact] + public async Task RenamesTheWithCancellationOverload() + { + const string inputCode = + """ + using System.Threading.Tasks; + using Funcky.Extensions; + + public static class C + { + public static void M(AsyncSource source) + { + _ = source.{|CS1061:InspectAwaitWithCancellation|}((x, cancellationToken) => Task.CompletedTask); + _ = source.{|CS1061:InspectAwaitWithCancellation|}(async (x, cancellationToken) => await Task.Yield()); + } + } + """; + const string fixedCode = + """ + using System.Threading.Tasks; + using Funcky.Extensions; + + public static class C + { + public static void M(AsyncSource source) + { + _ = source.Inspect((x, cancellationToken) => Task.CompletedTask); + _ = source.Inspect(async (x, cancellationToken) => await Task.Yield()); + } + } + """; + + await CreateTest(inputCode, fixedCode).RunAsync(CancellationToken.None); + } + + [Fact] + public async Task AddsTheDiscardedTokenParameterToLambdas() + { + const string inputCode = + """ + using System.Threading; + using System.Threading.Tasks; + using Funcky.Extensions; + + public static class C + { + public static void M(AsyncSource source) + { + _ = source.{|CS1061:InspectAwait|}(x => Task.CompletedTask); + _ = source.{|CS1061:InspectAwait|}(async x => await Task.Yield()); + _ = source.{|CS1061:InspectAwait|}((int x) => Task.CompletedTask); + _ = source.{|CS1061:InspectAwait|}(x => + { + return Task.CompletedTask; + }); + _ = source.{|CS1061:ExclusiveScanAwait|}(0, (sum, x) => Task.FromResult(sum + x)); + _ = source.{|CS1061:AdjacentGroupByAwait|}(x => Task.FromResult(x), (key, group) => Task.FromResult(key)); + } + } + """; + const string fixedCode = + """ + using System.Threading; + using System.Threading.Tasks; + using Funcky.Extensions; + + public static class C + { + public static void M(AsyncSource source) + { + _ = source.Inspect((x, _) => Task.CompletedTask); + _ = source.Inspect(async (x, _) => await Task.Yield()); + _ = source.Inspect((int x, CancellationToken _) => Task.CompletedTask); + _ = source.Inspect((x, _) => + { + return Task.CompletedTask; + }); + _ = source.ExclusiveScan(0, (sum, x, _) => Task.FromResult(sum + x)); + _ = source.AdjacentGroupBy((x, _) => Task.FromResult(x), (key, group, _) => Task.FromResult(key)); + } + } + """; + + await CreateTest(inputCode, fixedCode).RunAsync(CancellationToken.None); + } + + [Fact] + public async Task WrapsAMethodGroupOrADelegateInAForwardingLambda() + { + const string inputCode = + """ + using System; + using System.Threading.Tasks; + using Funcky.Extensions; + + public static class C + { + public static void M(AsyncSource source, Func> accumulate) + { + _ = source.{|CS1061:InspectAwait|}(Log); + _ = source.{|CS1061:ExclusiveScanAwait|}(0, accumulate); + } + + private static Task Log(int x) => Task.CompletedTask; + } + """; + const string fixedCode = + """ + using System; + using System.Threading.Tasks; + using Funcky.Extensions; + + public static class C + { + public static void M(AsyncSource source, Func> accumulate) + { + _ = source.Inspect((x, _) => Log(x)); + _ = source.ExclusiveScan(0, (x, y, _) => accumulate(x, y)); + } + + private static Task Log(int x) => Task.CompletedTask; + } + """; + + await CreateTest(inputCode, fixedCode).RunAsync(CancellationToken.None); + } + + [Fact] + public async Task RenamesTheTerminalAggregations() + { + const string inputCode = + """ + using System.Threading; + using System.Threading.Tasks; + using Funcky.Extensions; + + public static class C + { + public static async Task M(AsyncSource source, CancellationToken cancellationToken) + { + _ = await source.{|CS1061:FirstOrNoneAwaitAsync|}(x => Task.FromResult(x > 1)); + _ = await source.{|CS1061:FirstOrNoneAwaitAsync|}(x => Task.FromResult(x > 1), cancellationToken); + _ = await source.{|CS1061:FirstOrNoneAwaitWithCancellationAsync|}((x, token) => Task.FromResult(x > 1), cancellationToken); + _ = await source.{|CS1061:PartitionAwaitAsync|}(x => Task.FromResult(x > 1), (left, right) => Task.FromResult(left.Length)); + } + } + """; + const string fixedCode = + """ + using System.Threading; + using System.Threading.Tasks; + using Funcky.Extensions; + + public static class C + { + public static async Task M(AsyncSource source, CancellationToken cancellationToken) + { + _ = await source.FirstOrNoneAsync((x, _) => Task.FromResult(x > 1)); + _ = await source.FirstOrNoneAsync((x, _) => Task.FromResult(x > 1), cancellationToken); + _ = await source.FirstOrNoneAsync((x, token) => Task.FromResult(x > 1), cancellationToken); + _ = await source.PartitionAsync((x, _) => Task.FromResult(x > 1), (left, right, _) => Task.FromResult(left.Length)); + } + } + """; + + await CreateTest(inputCode, fixedCode).RunAsync(CancellationToken.None); + } + + [Fact] + public async Task OffersNoFixForACallableThatWouldBeEvaluatedPerElement() + { + const string inputCode = + """ + using System; + using System.Threading.Tasks; + using Funcky.Extensions; + + public static class C + { + public static async Task M(AsyncSource strings, Func> predicate) + { + _ = await strings.{|CS1061:FirstOrNoneAwaitAsync|}(predicate); + _ = await strings.{|CS1061:FirstOrNoneAwaitAsync|}(CreatePredicate()); + } + + private static Func> CreatePredicate() => _ => Task.FromResult(true); + } + """; + const string fixedCode = + """ + using System; + using System.Threading.Tasks; + using Funcky.Extensions; + + public static class C + { + public static async Task M(AsyncSource strings, Func> predicate) + { + _ = await strings.FirstOrNoneAsync((x, _) => predicate(x)); + _ = await strings.{|CS1061:FirstOrNoneAwaitAsync|}(CreatePredicate()); + } + + private static Func> CreatePredicate() => _ => Task.FromResult(true); + } + """; + + await CreateTest(inputCode, fixedCode).RunAsync(CancellationToken.None); + } + + [Fact] + public async Task OffersNoFixWhenTheCallIsNotOneOfTheRemovedOperators() + { + const string inputCode = + """ + using System.Threading.Tasks; + using Funcky.Extensions; + + public static class C + { + public static void M(AsyncSource source, string text) + { + _ = text.{|CS1061:InspectAwait|}(x => Task.CompletedTask); + _ = source.{|CS1061:LegacyAwait|}(x => Task.CompletedTask); + _ = source.{|CS1061:InspectAwait|}(inspector: x => Task.CompletedTask); + } + } + """; + + await CreateTest(inputCode, inputCode).RunAsync(CancellationToken.None); + } + + private static VerifyCS.Test CreateTest(string inputCode, string fixedCode) + => new() + { + TestCode = inputCode + Environment.NewLine + StubCode, + FixedCode = fixedCode + Environment.NewLine + StubCode, + DisabledDiagnostics = { MissingXmlComment }, + FixedState = { MarkupHandling = MarkupMode.Allow }, + }; +} diff --git a/Funcky.Async.Test/Funcky.Async.Test.csproj b/Funcky.Async.Test/Funcky.Async.Test.csproj index ea7fc7fe1..0c861abd6 100644 --- a/Funcky.Async.Test/Funcky.Async.Test.csproj +++ b/Funcky.Async.Test/Funcky.Async.Test.csproj @@ -5,16 +5,15 @@ enable false - $(DefineConstants);ASYNC_SUPPORTED;SYSTEM_LINQ_ASYNC + and are linked into this project to run against Funcky.Async and System.Linq.AsyncEnumerable. --> + $(DefineConstants);ASYNC_SUPPORTED - - + + @@ -44,8 +43,6 @@ - - diff --git a/Funcky.Async.Test/TestUtilities/SystemLinqAsyncTestAdapter.cs b/Funcky.Async.Test/TestUtilities/SystemLinqAsyncTestAdapter.cs deleted file mode 100644 index 008c8fc1b..000000000 --- a/Funcky.Async.Test/TestUtilities/SystemLinqAsyncTestAdapter.cs +++ /dev/null @@ -1,11 +0,0 @@ -namespace Funcky.Extensions; - -/// -/// .NET 10 operator shapes used by the shared async tests that the library's own -/// does not need. -/// -internal static class SystemLinqAsyncTestAdapter -{ - public static ValueTask AllAsync(this IAsyncEnumerable source, Func> predicate, CancellationToken cancellationToken = default) - => source.AllAwaitWithCancellationAsync(predicate, cancellationToken); -} diff --git a/Funcky.Async/CompatibilitySuppressions.xml b/Funcky.Async/CompatibilitySuppressions.xml index fb4a9a933..e765a4e5c 100644 --- a/Funcky.Async/CompatibilitySuppressions.xml +++ b/Funcky.Async/CompatibilitySuppressions.xml @@ -1,106 +1,3 @@ - + - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy``2(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,``1},System.Collections.Generic.IEqualityComparer{``1}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy``2(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,``1}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy``2(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask{``1}},System.Collections.Generic.IEqualityComparer{``1}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy``2(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask{``1}}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy``3(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2},System.Collections.Generic.IEqualityComparer{``1}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy``3(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,``1},System.Func{``0,``2}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy``3(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask{``1}},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask{``2}},System.Collections.Generic.IEqualityComparer{``1}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy``3(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask{``1}},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask{``2}}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait``2(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,System.Threading.Tasks.ValueTask{``1}},System.Collections.Generic.IEqualityComparer{``1}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait``2(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,System.Threading.Tasks.ValueTask{``1}}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait``3(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,System.Threading.Tasks.ValueTask{``1}},System.Func{``0,System.Threading.Tasks.ValueTask{``2}},System.Collections.Generic.IEqualityComparer{``1}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait``3(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,System.Threading.Tasks.ValueTask{``1}},System.Func{``0,System.Threading.Tasks.ValueTask{``2}}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation``2(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask{``1}},System.Collections.Generic.IEqualityComparer{``1}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation``2(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask{``1}}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation``3(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask{``1}},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask{``2}},System.Collections.Generic.IEqualityComparer{``1}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation``3(System.Collections.Generic.IAsyncEnumerable{``0},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask{``1}},System.Func{``0,System.Threading.CancellationToken,System.Threading.Tasks.ValueTask{``2}}) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - - CP0002 - M:Funcky.Extensions.AsyncEnumerableExtensions.Chunk``1(System.Collections.Generic.IAsyncEnumerable{``0},System.Int32) - lib/net9.0/Funcky.Async.dll - lib/net10.0/Funcky.Async.dll - - \ No newline at end of file + \ No newline at end of file diff --git a/Funcky.Async/Extensions/AsyncEnumerableExtensions/AsyncGrouping.cs b/Funcky.Async/Extensions/AsyncEnumerableExtensions/AsyncGrouping.cs deleted file mode 100644 index 954a56832..000000000 --- a/Funcky.Async/Extensions/AsyncEnumerableExtensions/AsyncGrouping.cs +++ /dev/null @@ -1,31 +0,0 @@ -#if SYSTEM_LINQ_ASYNC -using System.Collections.Immutable; - -namespace Funcky.Extensions; - -public static partial class AsyncEnumerableExtensions -{ - internal class AsyncGrouping : IAsyncGrouping - { - private readonly IImmutableList _elements; - - internal AsyncGrouping(TKey key, IImmutableList elements) - { - Key = key; - _elements = elements; - } - - public TKey Key { get; } - -#pragma warning disable CS1998 - public async IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) -#pragma warning restore CS1998 - { - foreach (var element in _elements) - { - yield return element; - } - } - } -} -#endif diff --git a/Funcky.Async/Funcky.Async.csproj b/Funcky.Async/Funcky.Async.csproj index 4eaa035fe..c1c718cf7 100644 --- a/Funcky.Async/Funcky.Async.csproj +++ b/Funcky.Async/Funcky.Async.csproj @@ -4,11 +4,12 @@ async APIs live in the Funcky package itself. The net10.0 asset of this package therefore only contains type forwards to Funcky, so projects that reference both packages keep compiling. On older frameworks this package compiles Funcky's async sources (linked from the Funcky project) - against System.Linq.Async; see Internal\SystemLinqAsyncAdapter.cs for how the two operator - vocabularies are bridged. The package is compiled against the lowest supported System.Linq.Async - version (5.0.0) so that the shipped binary works with every version in the allowed range; CI runs - the tests against each version of the range (see the SystemLinqAsyncVersion matrix in build.yml - and Funcky.Async.Test.csproj), which exercises exactly the binary compatibility consumers rely on. --> + against System.Linq.AsyncEnumerable, the very package that is part of the .NET 10 base class library, + so the shared sources need no conditional compilation (see Directory.Packages.props for why it is not + System.Linq.Async 7). The package is compiled against the lowest supported version of the range so that + the shipped binary works with every version in it; CI runs the tests against the floor and the newest + version (see the SystemLinqAsyncEnumerableVersion matrix in build.yml and Funcky.Async.Test.csproj), + which exercises exactly the binary compatibility consumers rely on. --> net9.0 net11.0;net10.0;$(FunckyNewestTargetFramework);net8.0;netstandard2.1;netstandard2.0 preview @@ -17,7 +18,7 @@ false Extends Funcky with support for IAsyncEnumerable and Tasks on frameworks older than .NET 10. On .NET 10 and newer these APIs are part of the Funcky package and this package only forwards to them. Functional Async Monad Linq - 1.6.0 + 2.0.0 true snupkg icon.png @@ -38,9 +39,8 @@ true - - $(DefineConstants);ASYNC_SUPPORTED;SYSTEM_LINQ_ASYNC + + $(DefineConstants);ASYNC_SUPPORTED true @@ -66,6 +66,7 @@ + @@ -83,7 +84,7 @@ - + diff --git a/Funcky.Async/Internal/SystemLinqAsyncAdapter.cs b/Funcky.Async/Internal/SystemLinqAsyncAdapter.cs deleted file mode 100644 index 7f955e437..000000000 --- a/Funcky.Async/Internal/SystemLinqAsyncAdapter.cs +++ /dev/null @@ -1,35 +0,0 @@ -#if SYSTEM_LINQ_ASYNC -namespace Funcky.Extensions; - -/// -/// Funcky's async sources are written against the IAsyncEnumerable LINQ operators that ship with .NET 10. -/// On older frameworks the same sources are compiled against System.Linq.Async, which names the operators -/// taking asynchronous callbacks differently (SelectAwaitWithCancellation, WhereAwaitWithCancellation, …). -/// These adapters provide the .NET 10 shapes on top of System.Linq.Async so the shared sources need no conditional compilation. -/// -internal static class SystemLinqAsyncAdapter -{ - extension(IAsyncEnumerable source) - { - [Pure] - public IAsyncEnumerable Where(Func> predicate) - => source.WhereAwaitWithCancellation(predicate); - - [Pure] - public IAsyncEnumerable Select(Func> selector) - => source.SelectAwaitWithCancellation(selector); - - [Pure] - public IAsyncEnumerable Select(Func> selector) - => source.SelectAwaitWithCancellation(selector); - - [Pure] - public ValueTask AnyAsync(Func> predicate, CancellationToken cancellationToken = default) - => source.AnyAwaitWithCancellationAsync(predicate, cancellationToken); - - [Pure] - public ValueTask AggregateAsync(TAccumulate seed, Func> accumulator, CancellationToken cancellationToken = default) - => source.AggregateAwaitWithCancellationAsync(seed, accumulator, cancellationToken); - } -} -#endif diff --git a/Funcky.Async/PublicAPI/common/PublicAPI.Unshipped.txt b/Funcky.Async/PublicAPI/common/PublicAPI.Unshipped.txt index 7dc5c5811..82896d627 100644 --- a/Funcky.Async/PublicAPI/common/PublicAPI.Unshipped.txt +++ b/Funcky.Async/PublicAPI/common/PublicAPI.Unshipped.txt @@ -1 +1,135 @@ #nullable enable +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Func!, System.Collections.Generic.IReadOnlyList!, System.Threading.Tasks.ValueTask>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Func!, System.Collections.Generic.IReadOnlyList!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).Chunk(int size) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ChunkAwait(int size, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ChunkAwaitWithCancellation(int size, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ExclusiveScanAwait(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ExclusiveScanAwaitWithCancellation(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).FirstOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).FirstOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InclusiveScanAwait(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InclusiveScanAwaitWithCancellation(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InspectAwait(System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InspectAwaitWithCancellation(System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).LastOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).LastOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).NoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).NoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).SingleOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).SingleOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwait(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwait(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwaitWithCancellation(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwaitWithCancellation(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.Chunk(this System.Collections.Generic.IAsyncEnumerable! source, int size) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ChunkAwait(this System.Collections.Generic.IAsyncEnumerable! source, int size, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ChunkAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, int size, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ExclusiveScanAwait(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ExclusiveScanAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.FirstOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.FirstOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InclusiveScanAwait(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InclusiveScanAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InspectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InspectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.LastOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.LastOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.NoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.NoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.SingleOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.SingleOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! diff --git a/Funcky.Async/PublicAPI/net10.0/PublicAPI.Unshipped.txt b/Funcky.Async/PublicAPI/net10.0/PublicAPI.Unshipped.txt index 7dc5c5811..ef12ad0a8 100644 --- a/Funcky.Async/PublicAPI/net10.0/PublicAPI.Unshipped.txt +++ b/Funcky.Async/PublicAPI/net10.0/PublicAPI.Unshipped.txt @@ -1 +1,117 @@ #nullable enable +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ChunkAwait(this System.Collections.Generic.IAsyncEnumerable! source, int size, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ChunkAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, int size, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ExclusiveScanAwait(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ExclusiveScanAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.FirstOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.FirstOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InclusiveScanAwait(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InclusiveScanAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InspectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InspectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.LastOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.LastOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.NoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.NoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Func!, System.Collections.Generic.IReadOnlyList!, System.Threading.Tasks.ValueTask>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Func!, System.Collections.Generic.IReadOnlyList!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.SingleOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.SingleOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ChunkAwait(int size, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ChunkAwaitWithCancellation(int size, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ExclusiveScanAwait(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ExclusiveScanAwaitWithCancellation(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).FirstOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).FirstOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InclusiveScanAwait(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InclusiveScanAwaitWithCancellation(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InspectAwait(System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InspectAwaitWithCancellation(System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).LastOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).LastOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).NoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).NoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).SingleOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).SingleOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwait(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwait(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwaitWithCancellation(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwaitWithCancellation(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) diff --git a/Funcky.Async/PublicAPI/net11.0/PublicAPI.Unshipped.txt b/Funcky.Async/PublicAPI/net11.0/PublicAPI.Unshipped.txt index 7dc5c5811..ef12ad0a8 100644 --- a/Funcky.Async/PublicAPI/net11.0/PublicAPI.Unshipped.txt +++ b/Funcky.Async/PublicAPI/net11.0/PublicAPI.Unshipped.txt @@ -1 +1,117 @@ #nullable enable +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ChunkAwait(this System.Collections.Generic.IAsyncEnumerable! source, int size, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ChunkAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, int size, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ExclusiveScanAwait(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ExclusiveScanAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.FirstOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.FirstOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InclusiveScanAwait(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InclusiveScanAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InspectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InspectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.LastOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.LastOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.NoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.NoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Func!, System.Collections.Generic.IReadOnlyList!, System.Threading.Tasks.ValueTask>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Func!, System.Collections.Generic.IReadOnlyList!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.SingleOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.SingleOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ChunkAwait(int size, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ChunkAwaitWithCancellation(int size, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ExclusiveScanAwait(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ExclusiveScanAwaitWithCancellation(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).FirstOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).FirstOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InclusiveScanAwait(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InclusiveScanAwaitWithCancellation(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InspectAwait(System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InspectAwaitWithCancellation(System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).LastOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).LastOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).NoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).NoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).SingleOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).SingleOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwait(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwait(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwaitWithCancellation(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwaitWithCancellation(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! (forwarded, contained in Funcky) diff --git a/Funcky.Async/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt b/Funcky.Async/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt index 7dc5c5811..82896d627 100644 --- a/Funcky.Async/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt +++ b/Funcky.Async/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt @@ -1 +1,135 @@ #nullable enable +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector, System.Func! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector, System.Func! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Func!, System.Collections.Generic.IReadOnlyList!, System.Threading.Tasks.ValueTask>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Func!, System.Collections.Generic.IReadOnlyList!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).Chunk(int size) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ChunkAwait(int size, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ChunkAwaitWithCancellation(int size, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ExclusiveScanAwait(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ExclusiveScanAwaitWithCancellation(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).FirstOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).FirstOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InclusiveScanAwait(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InclusiveScanAwaitWithCancellation(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InspectAwait(System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InspectAwaitWithCancellation(System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).LastOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).LastOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).NoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).NoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).SingleOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).SingleOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwait(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwait(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwaitWithCancellation(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwaitWithCancellation(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.Chunk(this System.Collections.Generic.IAsyncEnumerable! source, int size) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ChunkAwait(this System.Collections.Generic.IAsyncEnumerable! source, int size, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ChunkAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, int size, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ExclusiveScanAwait(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ExclusiveScanAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.FirstOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.FirstOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InclusiveScanAwait(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InclusiveScanAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InspectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InspectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.LastOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.LastOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.NoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.NoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.SingleOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.SingleOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupBy(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! diff --git a/Funcky.Async/package.md b/Funcky.Async/package.md index 4dd401114..6dbaef18c 100644 --- a/Funcky.Async/package.md +++ b/Funcky.Async/package.md @@ -7,6 +7,11 @@ these APIs are part of the [Funcky] package itself. The `net10.0` and `net11.0` only forward their types to `Funcky`, so existing projects keep compiling. Once you target .NET 10 or newer, you can remove the reference to `Funcky.Async`. +On older frameworks the package builds on [System.Linq.AsyncEnumerable](https://www.nuget.org/packages/System.Linq.AsyncEnumerable), +the `IAsyncEnumerable` LINQ of .NET 10 as a package, so the operators have the same shapes everywhere. A reference to +[System.Linq.Async](https://www.nuget.org/packages/System.Linq.Async) 5 or 6 next to it clashes (CS0433); upgrade it to +System.Linq.Async 7 or drop it. Projects that cannot stay on Funcky.Async 1.x. + ## Main Types * `Funcky.AsyncSequence`—Generate asynchronous sequences. * `Funcky.Extensions.AsyncEnumerableExtensions`—Extensions for `IAsyncEnumerable`. diff --git a/Funcky.Test/AsyncGenerator.cs b/Funcky.Test/AsyncGenerator.cs index 43691f831..3a1711d78 100644 --- a/Funcky.Test/AsyncGenerator.cs +++ b/Funcky.Test/AsyncGenerator.cs @@ -9,20 +9,12 @@ internal static class AsyncGenerator public static Arbitrary> GenerateAsyncEnumerable(IArbMap map) => map.GeneratorFor>().Select(list => list.ToAsyncEnumerable()).ToArbitrary(); - public static Arbitrary> GenerateAwaitSelector(IArbMap map) - => map.GeneratorFor>().Select(ResultToValueTask).ToArbitrary(); - public static Arbitrary> GenerateAwaitWithCancellationSelector(IArbMap map) => map.GeneratorFor>().Select(ResultToValueTaskX).ToArbitrary(); - private static AwaitSelector ResultToValueTask(Func f) - => new(value => ValueTask.FromResult(f(value))); - private static AwaitSelectorWithCancellation ResultToValueTaskX(Func f) => new((value, _) => ValueTask.FromResult(f(value))); } -public sealed record AwaitSelector(Func> Get); - public sealed record AwaitSelectorWithCancellation(Func> Get); #endif diff --git a/Funcky.Test/Extensions/AsyncEnumerableExtensions/AdjacentGroupByTest.cs b/Funcky.Test/Extensions/AsyncEnumerableExtensions/AdjacentGroupByTest.cs index ac30c9498..04ee2637b 100644 --- a/Funcky.Test/Extensions/AsyncEnumerableExtensions/AdjacentGroupByTest.cs +++ b/Funcky.Test/Extensions/AsyncEnumerableExtensions/AdjacentGroupByTest.cs @@ -47,11 +47,7 @@ public async Task GivenConstantKeySelectorOneGroupWithTheConstantsKeyWillBeSelec var grouping = await AsyncAssert.Single(group); Assert.Equal(groupKey, grouping.Key); -#if SYSTEM_LINQ_ASYNC - Assert.Equal(elementCount, await grouping.CountAsync()); -#else Assert.Equal(elementCount, grouping.Count()); -#endif } [Fact] @@ -71,11 +67,7 @@ public async Task GivenAYearGroupByCreatesMonthsCorrectly() Assert.Equal(DaysInALeapYear, await dates.CountAsync()); Assert.Equal(MonthsInAYear, await months.CountAsync()); -#if SYSTEM_LINQ_ASYNC - await AsyncAssert.Equal(DaysInMonthsOfALeapYear(), months.SelectAwait(async month => await month.CountAsync())); -#else await AsyncAssert.Equal(DaysInMonthsOfALeapYear(), months.Select((month, _) => month.Count())); -#endif } [Fact] @@ -87,11 +79,7 @@ public async Task GivenTwoYearsGroupByAdjacentGroupsJanuaryOfTwoDifferentYearsIn Assert.Equal(DaysInAYear + DaysInALeapYear, await dates.CountAsync()); Assert.Equal(2 * MonthsInAYear, await months.CountAsync()); -#if SYSTEM_LINQ_ASYNC - await AsyncAssert.Equal(DaysInMonthsOfAYear().Concat(DaysInMonthsOfALeapYear()), months.SelectAwait(async month => await month.CountAsync())); -#else await AsyncAssert.Equal(DaysInMonthsOfAYear().Concat(DaysInMonthsOfALeapYear()), months.Select((month, _) => month.Count())); -#endif } [Fact] @@ -110,11 +98,7 @@ public async Task GivenAdjacentGroupByWithElementSelectorProjectsTheResultCorrec var numbers = AsyncEnumerable.Range(1, 5); var grouped = numbers.AdjacentGroupBy(number => number / 3, number => number * -1); -#if SYSTEM_LINQ_ASYNC - Assert.Equal("-3,-4,-5", string.Join(",", await (await grouped.LastAsync()).ToListAsync())); -#else Assert.Equal("-3,-4,-5", string.Join(",", await grouped.LastAsync())); -#endif } #pragma warning disable CS1998 diff --git a/Funcky.Test/Extensions/AsyncEnumerableExtensions/ArgumentValidationTest.cs b/Funcky.Test/Extensions/AsyncEnumerableExtensions/ArgumentValidationTest.cs index 47dddd23f..f6e3b0442 100644 --- a/Funcky.Test/Extensions/AsyncEnumerableExtensions/ArgumentValidationTest.cs +++ b/Funcky.Test/Extensions/AsyncEnumerableExtensions/ArgumentValidationTest.cs @@ -1,4 +1,3 @@ -#pragma warning disable CS0618 // The …Await and …AwaitWithCancellation overloads are obsolete but keep working until 4.0.0. #pragma warning disable IDISP005 // The calls only check that the method throws; no result is ever created. #if ASYNC_SUPPORTED namespace Funcky.Async.Test.Extensions.AsyncEnumerableExtensions; @@ -18,10 +17,6 @@ public static TheoryData> CallsWithANullArgument() { "elementSelector", () => Source.AdjacentGroupBy(Identity, (Func)null!) }, { "resultSelector", () => Source.AdjacentGroupBy(Identity, (Func, int>)null!) }, { "comparer", () => Source.AdjacentGroupBy(Identity, (IEqualityComparer)null!) }, - { "source", () => NullSource.AdjacentGroupByAwait(x => ValueTask.FromResult(x)) }, - { "keySelector", () => Source.AdjacentGroupByAwait((Func>)null!) }, - { "source", () => NullSource.AdjacentGroupByAwaitWithCancellation((x, _) => ValueTask.FromResult(x)) }, - { "keySelector", () => Source.AdjacentGroupByAwaitWithCancellation((Func>)null!) }, { "source", () => NullSource.AdjacentGroupBy((x, _) => ValueTask.FromResult(x)) }, { "keySelector", () => Source.AdjacentGroupBy((Func>)null!) }, { "elementSelector", () => Source.AdjacentGroupBy((x, _) => ValueTask.FromResult(x), (Func>)null!) }, @@ -35,28 +30,16 @@ public static TheoryData> CallsWithANullArgument() { "fallback", () => Source.AnyOrElse((Func>)null!) }, { "source", () => NullSource.Chunk(2, Identity) }, { "resultSelector", () => Source.Chunk(2, (Func, int>)null!) }, - { "resultSelector", () => Source.ChunkAwait(2, (Func, ValueTask>)null!) }, - { "resultSelector", () => Source.ChunkAwaitWithCancellation(2, (Func, CancellationToken, ValueTask>)null!) }, { "resultSelector", () => Source.Chunk(2, (Func, CancellationToken, ValueTask>)null!) }, { "source", () => NullSource.Inspect(NoOperation) }, { "inspector", () => Source.Inspect(null!) }, - { "inspector", () => Source.InspectAwait(null!) }, - { "inspector", () => Source.InspectAwaitWithCancellation(null!) }, { "inspector", () => Source.Inspect((Func)null!) }, { "source", () => NullSource.InspectEmpty(NoOperation) }, { "inspector", () => Source.InspectEmpty(null!) }, { "source", () => NullSource.Interleave(Source) }, { "otherSources", () => Source.Interleave(null!) }, { "source", () => NullSources.Interleave() }, - { "source", () => NullSource.MaxOrNoneAwaitAsync(item => ValueTask.FromResult(item)) }, - { "selector", () => Source.MaxOrNoneAwaitAsync((Func>)null!) }, - { "source", () => NullSource.MaxOrNoneAwaitAsync(item => ValueTask.FromResult(Option.Some(item))) }, - { "selector", () => Source.MaxOrNoneAwaitAsync((Func>>)null!) }, { "source", () => NullSource.Memoize() }, - { "source", () => NullSource.MinOrNoneAwaitAsync(item => ValueTask.FromResult(item)) }, - { "selector", () => Source.MinOrNoneAwaitAsync((Func>)null!) }, - { "source", () => NullSource.MinOrNoneAwaitAsync(item => ValueTask.FromResult(Option.Some(item))) }, - { "selector", () => Source.MinOrNoneAwaitAsync((Func>>)null!) }, { "source1", () => NullSource.Merge(Source) }, { "source2", () => Source.Merge(NullSource) }, { "source3", () => Source.Merge(Source, NullSource) }, @@ -68,14 +51,6 @@ public static TheoryData> CallsWithANullArgument() { "selector", () => Source.WhereSelect((Func>)null!) }, { "source", () => NullSource.WhereSelect((item, index) => Option.Some(item + index)) }, { "selector", () => Source.WhereSelect((Func>)null!) }, - { "source", () => NullSource.WhereSelectAwait(item => ValueTask.FromResult(Option.Some(item))) }, - { "selector", () => Source.WhereSelectAwait((Func>>)null!) }, - { "source", () => NullSource.WhereSelectAwait((item, index) => ValueTask.FromResult(Option.Some(item + index))) }, - { "selector", () => Source.WhereSelectAwait((Func>>)null!) }, - { "source", () => NullSource.WhereSelectAwaitWithCancellation((item, _) => ValueTask.FromResult(Option.Some(item))) }, - { "selector", () => Source.WhereSelectAwaitWithCancellation((Func>>)null!) }, - { "source", () => NullSource.WhereSelectAwaitWithCancellation((item, index, _) => ValueTask.FromResult(Option.Some(item + index))) }, - { "selector", () => Source.WhereSelectAwaitWithCancellation((Func>>)null!) }, { "source", () => NullSource.WhereSelect((item, _) => ValueTask.FromResult(Option.Some(item))) }, { "selector", () => Source.WhereSelect((Func>>)null!) }, { "source", () => NullSource.WhereSelect((item, index, _) => ValueTask.FromResult(Option.Some(item + index))) }, @@ -83,13 +58,9 @@ public static TheoryData> CallsWithANullArgument() { "source", () => NullSource.PowerSet() }, { "source", () => NullSource.InclusiveScan(0, (a, b) => a + b) }, { "accumulator", () => Source.InclusiveScan(0, (Func)null!) }, - { "accumulator", () => Source.InclusiveScanAwait(0, (Func>)null!) }, - { "accumulator", () => Source.InclusiveScanAwaitWithCancellation(0, (Func>)null!) }, { "accumulator", () => Source.InclusiveScan(0, (Func>)null!) }, { "source", () => NullSource.ExclusiveScan(0, (a, b) => a + b) }, { "accumulator", () => Source.ExclusiveScan(0, (Func)null!) }, - { "accumulator", () => Source.ExclusiveScanAwait(0, (Func>)null!) }, - { "accumulator", () => Source.ExclusiveScanAwaitWithCancellation(0, (Func>)null!) }, { "accumulator", () => Source.ExclusiveScan(0, (Func>)null!) }, { "source", () => NullSource.SlidingWindow(2) }, { "source", () => NullSource.Split(1) }, diff --git a/Funcky.Test/Extensions/AsyncEnumerableExtensions/AverageOrNoneTest.cs b/Funcky.Test/Extensions/AsyncEnumerableExtensions/AverageOrNoneTest.cs index a64d22533..4e9eae2ec 100644 --- a/Funcky.Test/Extensions/AsyncEnumerableExtensions/AverageOrNoneTest.cs +++ b/Funcky.Test/Extensions/AsyncEnumerableExtensions/AverageOrNoneTest.cs @@ -1,4 +1,3 @@ -#pragma warning disable CS0618 // The …AwaitAsync overloads are obsolete but keep working until 4.0.0. #if ASYNC_SUPPORTED // ReSharper disable PossibleMultipleEnumeration using FsCheck; @@ -24,11 +23,6 @@ public Property AverageOrNoneAsyncWithSelectorGivesTheSameResultAsAverageForNull => (Option.FromNullable(sequence.Select(selector).AverageAsync().Result) == sequence.Select(Option.FromNullable).AverageOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property AverageOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsAverageForNullableAsyncForInt32(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((int? item, CancellationToken _) => selector.Get(item)).AverageAsync().Result) - == sequence.Select(Option.FromNullable).AverageOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property AverageOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsAverageForNullableAsyncForInt32(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).AverageAsync().Result) @@ -49,11 +43,6 @@ public Property AverageOrNoneAsyncWithSelectorGivesTheSameResultAsAverageForNull => (Option.FromNullable(sequence.Select(selector).AverageAsync().Result) == sequence.Select(Option.FromNullable).AverageOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property AverageOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsAverageForNullableAsyncForInt64(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((long? item, CancellationToken _) => selector.Get(item)).AverageAsync().Result) - == sequence.Select(Option.FromNullable).AverageOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property AverageOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsAverageForNullableAsyncForInt64(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).AverageAsync().Result) @@ -74,11 +63,6 @@ public Property AverageOrNoneAsyncWithSelectorGivesTheSameResultAsAverageForNull => (Option.FromNullable(sequence.Select(selector).AverageAsync().Result) == sequence.Select(Option.FromNullable).AverageOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property AverageOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsAverageForNullableAsyncForSingle(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((float? item, CancellationToken _) => selector.Get(item)).AverageAsync().Result) - == sequence.Select(Option.FromNullable).AverageOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property AverageOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsAverageForNullableAsyncForSingle(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).AverageAsync().Result) @@ -99,11 +83,6 @@ public Property AverageOrNoneAsyncWithSelectorGivesTheSameResultAsAverageForNull => (Option.FromNullable(sequence.Select(selector).AverageAsync().Result) == sequence.Select(Option.FromNullable).AverageOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property AverageOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsAverageForNullableAsyncForDouble(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((double? item, CancellationToken _) => selector.Get(item)).AverageAsync().Result) - == sequence.Select(Option.FromNullable).AverageOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property AverageOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsAverageForNullableAsyncForDouble(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).AverageAsync().Result) @@ -124,11 +103,6 @@ public Property AverageOrNoneAsyncWithSelectorGivesTheSameResultAsAverageForNull => (Option.FromNullable(sequence.Select(selector).AverageAsync().Result) == sequence.Select(Option.FromNullable).AverageOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property AverageOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsAverageForNullableAsyncForDecimal(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((decimal? item, CancellationToken _) => selector.Get(item)).AverageAsync().Result) - == sequence.Select(Option.FromNullable).AverageOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property AverageOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsAverageForNullableAsyncForDecimal(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).AverageAsync().Result) diff --git a/Funcky.Test/Extensions/AsyncEnumerableExtensions/ChunkTest.cs b/Funcky.Test/Extensions/AsyncEnumerableExtensions/ChunkTest.cs index 52f131bf4..aa25cf87b 100644 --- a/Funcky.Test/Extensions/AsyncEnumerableExtensions/ChunkTest.cs +++ b/Funcky.Test/Extensions/AsyncEnumerableExtensions/ChunkTest.cs @@ -1,4 +1,3 @@ -#pragma warning disable CS0618 // The …Await and …AwaitWithCancellation overloads are obsolete but keep working until 4.0.0. #if ASYNC_SUPPORTED using Funcky.Async.Test.TestUtilities; @@ -28,28 +27,6 @@ public async Task ChunkWithResultSelectorAppliesTheSelectorCorrectlyToTheSubsequ } } - [Fact] - public async Task ChunkAwaitWithResultSelectorAppliesTheSelectorCorrectlyToTheSubsequenceAsync() - { - var magicSquare = AsyncSequence.Return(4, 9, 2, 3, 5, 7, 8, 1, 6); - - await foreach (var average in magicSquare.ChunkAwait(3, chunk => ValueTask.FromResult(chunk.Average()))) - { - Assert.Equal(5, average); - } - } - - [Fact] - public async Task ChunkAwaitWithCancellationWithResultSelectorAppliesTheSelectorCorrectlyToTheSubsequenceAsync() - { - var magicSquare = AsyncSequence.Return(4, 9, 2, 3, 5, 7, 8, 1, 6); - - await foreach (var average in magicSquare.ChunkAwaitWithCancellation(3, (chunk, _) => ValueTask.FromResult(chunk.Average()))) - { - Assert.Equal(5, average); - } - } - [Fact] public async Task GivenAnEnumerableNotAMultipleOfSizeWeHaveASmallerLastSlice() { @@ -71,91 +48,5 @@ public async Task CancellationIsPropagated() { await AsyncAssert.CancellationIsPropagated(new AssertIsCancellationRequestedAsyncSequence().Chunk(1, Enumerable.Count)); } - -#if SYSTEM_LINQ_ASYNC - // The Chunk(size) overload only exists in Funcky.Async; on .NET 10 the base class library provides it. - [Fact] - public async Task GivenAnEmptyEnumerableChunkReturnsAnEmptyListAsync() - { - var numbers = AsyncEnumerable.Empty(); - - var chunked = numbers.Chunk(3); - - await AsyncAssert.Empty(chunked); - } - - [Fact] - public async Task GivenAnSingleElementListWeGetEnumerableWithOneElement() - { - var numbers = AsyncSequence.Return(1); - - var chunked = numbers.Chunk(3); - var expected = AsyncSequence.Return(new List { 1 }); - - await AsyncAssert.Equal(expected, chunked); - } - - [Fact] - public async Task GivenAnEnumerableWeChanChunkItIntoAnEnumerableOfEnumerablesAsync() - { - var numbers = AsyncSequence.Return(1, 2, 3, 4, 5, 6, 7, 8, 9); - - var chunked = numbers.Chunk(3); - - await AsyncAssert.Collection( - chunked, - chunk => - { - Assert.Collection( - chunk, - value => Assert.Equal(1, value), - value => Assert.Equal(2, value), - value => Assert.Equal(3, value)); - }, - chunk => - { - Assert.Collection( - chunk, - value => Assert.Equal(4, value), - value => Assert.Equal(5, value), - value => Assert.Equal(6, value)); - }, - chunk => - { - Assert.Collection( - chunk, - value => Assert.Equal(7, value), - value => Assert.Equal(8, value), - value => Assert.Equal(9, value)); - }); - } - - [Fact] - public async Task GivenAnEnumerableNotAMultipleOfSizeWeHaveASmallerLastSliceWithoutResultSelector() - { - var numbers = AsyncSequence.Return("a", "b", "c", "d", "e", "g", "h", "i", "j"); - - const int chunkSize = 4; - var chunked = numbers.Chunk(chunkSize); - var count = await numbers.CountAsync(); - - await AsyncAssert.Collection( - chunked, - chunk => Assert.Equal(chunkSize, chunk.Count), - chunk => Assert.Equal(chunkSize, chunk.Count), - chunk => Assert.Equal(count % chunkSize, chunk.Count)); - } - - [Theory] - [InlineData(0)] - [InlineData(-1)] - [InlineData(-42)] - public void ChunkWithoutResultSelectorThrowsOnZeroOrNegativeChunkSizes(int invalidChunkSize) - { - var numbers = AsyncSequence.Return(1); - - Assert.Throws(() => numbers.Chunk(invalidChunkSize)); - } -#endif } #endif diff --git a/Funcky.Test/Extensions/AsyncEnumerableExtensions/InspectTest.cs b/Funcky.Test/Extensions/AsyncEnumerableExtensions/InspectTest.cs index d7075379b..926f8dd04 100644 --- a/Funcky.Test/Extensions/AsyncEnumerableExtensions/InspectTest.cs +++ b/Funcky.Test/Extensions/AsyncEnumerableExtensions/InspectTest.cs @@ -1,4 +1,3 @@ -#pragma warning disable CS0618 // The …Await and …AwaitWithCancellation overloads are obsolete but keep working until 4.0.0. #if ASYNC_SUPPORTED using Funcky.Async.Test.TestUtilities; @@ -14,14 +13,6 @@ public void InspectIsEnumeratedLazily() _ = doNotEnumerate.Inspect(NoOperation); } - [Fact] - public void InspectAwaitIsEnumeratedLazily() - { - var doNotEnumerate = new FailOnEnumerateAsyncSequence(); - - _ = doNotEnumerate.InspectAwait(static _ => ValueTask.CompletedTask); - } - [Fact] public async Task GivenAnAsyncEnumerableAndInjectWeCanApplySideEffectsToAsyncEnumerables() { @@ -38,36 +29,10 @@ public async Task GivenAnAsyncEnumerableAndInjectWeCanApplySideEffectsToAsyncEnu Assert.Equal(await numbers.CountAsync(), sideEffect); } - [Fact] - public async Task GivenAnAsyncEnumerableAndInjectAnAsynchronouseActionWeCanApplySideEffectsToAsyncEnumerables() - { - var sideEffect = 0; - var numbers = AsyncSequence.Return(1, 2, 3, 42); - - var numbersWithSideEffect = numbers - .InspectAwait(_ => - { - ++sideEffect; - return default; - }); - - Assert.Equal(0, sideEffect); - - await numbersWithSideEffect.ToListAsync(); - - Assert.Equal(await numbers.CountAsync(), sideEffect); - } - [Fact] public async Task CancellationIsPropagated() { await AsyncAssert.CancellationIsPropagated(new AssertIsCancellationRequestedAsyncSequence().Inspect(NoOperation)); } - - [Fact] - public async Task CancellationIsPropagatedInAwaitOverload() - { - await AsyncAssert.CancellationIsPropagated(new AssertIsCancellationRequestedAsyncSequence().InspectAwait(_ => ValueTask.CompletedTask)); - } } #endif diff --git a/Funcky.Test/Extensions/AsyncEnumerableExtensions/MaxOrNoneTest.cs b/Funcky.Test/Extensions/AsyncEnumerableExtensions/MaxOrNoneTest.cs index 02a80eb85..f37ed0521 100644 --- a/Funcky.Test/Extensions/AsyncEnumerableExtensions/MaxOrNoneTest.cs +++ b/Funcky.Test/Extensions/AsyncEnumerableExtensions/MaxOrNoneTest.cs @@ -1,4 +1,3 @@ -#pragma warning disable CS0618 // The …AwaitAsync overloads are obsolete but keep working until 4.0.0. #if ASYNC_SUPPORTED // ReSharper disable PossibleMultipleEnumeration using FsCheck; @@ -25,11 +24,6 @@ public Property MaxOrNoneAsyncWithSelectorGivesTheSameResultAsMaxForNullableAsyn => (Option.FromNullable(sequence.Select(selector).MaxAsync().Result) == sequence.Select(Option.FromNullable).MaxOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property MaxOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsMaxForNullableAsyncForInt32(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((int? item, CancellationToken _) => selector.Get(item)).MaxAsync().Result) - == sequence.Select(Option.FromNullable).MaxOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property MaxOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsMaxForNullableAsyncForInt32(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).MaxAsync().Result) @@ -50,11 +44,6 @@ public Property MaxOrNoneAsyncWithSelectorGivesTheSameResultAsMaxForNullableAsyn => (Option.FromNullable(sequence.Select(selector).MaxAsync().Result) == sequence.Select(Option.FromNullable).MaxOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property MaxOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsMaxForNullableAsyncForInt64(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((long? item, CancellationToken _) => selector.Get(item)).MaxAsync().Result) - == sequence.Select(Option.FromNullable).MaxOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property MaxOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsMaxForNullableAsyncForInt64(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).MaxAsync().Result) @@ -75,11 +64,6 @@ public Property MaxOrNoneAsyncWithSelectorGivesTheSameResultAsMaxForNullableAsyn => (Option.FromNullable(sequence.Select(selector).MaxAsync().Result) == sequence.Select(Option.FromNullable).MaxOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property MaxOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsMaxForNullableAsyncForSingle(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((float? item, CancellationToken _) => selector.Get(item)).MaxAsync().Result) - == sequence.Select(Option.FromNullable).MaxOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property MaxOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsMaxForNullableAsyncForSingle(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).MaxAsync().Result) @@ -100,11 +84,6 @@ public Property MaxOrNoneAsyncWithSelectorGivesTheSameResultAsMaxForNullableAsyn => (Option.FromNullable(sequence.Select(selector).MaxAsync().Result) == sequence.Select(Option.FromNullable).MaxOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property MaxOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsMaxForNullableAsyncForDouble(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((double? item, CancellationToken _) => selector.Get(item)).MaxAsync().Result) - == sequence.Select(Option.FromNullable).MaxOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property MaxOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsMaxForNullableAsyncForDouble(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).MaxAsync().Result) @@ -125,11 +104,6 @@ public Property MaxOrNoneAsyncWithSelectorGivesTheSameResultAsMaxForNullableAsyn => (Option.FromNullable(sequence.Select(selector).MaxAsync().Result) == sequence.Select(Option.FromNullable).MaxOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property MaxOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsMaxForNullableAsyncForDecimal(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((decimal? item, CancellationToken _) => selector.Get(item)).MaxAsync().Result) - == sequence.Select(Option.FromNullable).MaxOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property MaxOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsMaxForNullableAsyncForDecimal(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).MaxAsync().Result) @@ -150,11 +124,6 @@ public Property MaxOrNoneAsyncWithSelectorGivesTheSameResultAsMaxForNullableAsyn => (Option.FromNullable(sequence.Select(Person.Create).Select(SelectorTransformation.TransformPersonSelector(selector)).MaxAsync().Result) == sequence.Select(Person.Create).Select(Option.FromNullable).MaxOrNoneAsync(SelectorTransformation.TransformOptionPersonSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property MaxOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsMaxForNullableAsyncForAnyIComparable(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select(Person.Create).Select((Person? person, CancellationToken _) => SelectorTransformation.TransformPersonSelector(selector.Get)(person)).MaxAsync().Result) - == sequence.Select(Person.Create).Select(Option.FromNullable).MaxOrNoneAwaitAsync(SelectorTransformation.TransformOptionPersonSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property MaxOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsMaxForNullableAsyncForAnyIComparable(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) { diff --git a/Funcky.Test/Extensions/AsyncEnumerableExtensions/MinOrNoneTest.cs b/Funcky.Test/Extensions/AsyncEnumerableExtensions/MinOrNoneTest.cs index 05d626ec4..b2781b74a 100644 --- a/Funcky.Test/Extensions/AsyncEnumerableExtensions/MinOrNoneTest.cs +++ b/Funcky.Test/Extensions/AsyncEnumerableExtensions/MinOrNoneTest.cs @@ -1,4 +1,3 @@ -#pragma warning disable CS0618 // The …AwaitAsync overloads are obsolete but keep working until 4.0.0. #if ASYNC_SUPPORTED // ReSharper disable PossibleMultipleEnumeration using FsCheck; @@ -25,11 +24,6 @@ public Property MinOrNoneAsyncWithSelectorGivesTheSameResultAsMinForNullableAsyn => (Option.FromNullable(sequence.Select(selector).MinAsync().Result) == sequence.Select(Option.FromNullable).MinOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property MinOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsMinForNullableAsyncForInt32(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((int? item, CancellationToken _) => selector.Get(item)).MinAsync().Result) - == sequence.Select(Option.FromNullable).MinOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property MinOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsMinForNullableAsyncForInt32(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).MinAsync().Result) @@ -50,11 +44,6 @@ public Property MinOrNoneAsyncWithSelectorGivesTheSameResultAsMinForNullableAsyn => (Option.FromNullable(sequence.Select(selector).MinAsync().Result) == sequence.Select(Option.FromNullable).MinOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property MinOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsMinForNullableAsyncForInt64(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((long? item, CancellationToken _) => selector.Get(item)).MinAsync().Result) - == sequence.Select(Option.FromNullable).MinOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property MinOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsMinForNullableAsyncForInt64(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).MinAsync().Result) @@ -75,11 +64,6 @@ public Property MinOrNoneAsyncWithSelectorGivesTheSameResultAsMinForNullableAsyn => (Option.FromNullable(sequence.Select(selector).MinAsync().Result) == sequence.Select(Option.FromNullable).MinOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property MinOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsMinForNullableAsyncForSingle(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((float? item, CancellationToken _) => selector.Get(item)).MinAsync().Result) - == sequence.Select(Option.FromNullable).MinOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property MinOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsMinForNullableAsyncForSingle(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).MinAsync().Result) @@ -100,11 +84,6 @@ public Property MinOrNoneAsyncWithSelectorGivesTheSameResultAsMinForNullableAsyn => (Option.FromNullable(sequence.Select(selector).MinAsync().Result) == sequence.Select(Option.FromNullable).MinOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property MinOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsMinForNullableAsyncForDouble(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((double? item, CancellationToken _) => selector.Get(item)).MinAsync().Result) - == sequence.Select(Option.FromNullable).MinOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property MinOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsMinForNullableAsyncForDouble(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).MinAsync().Result) @@ -125,11 +104,6 @@ public Property MinOrNoneAsyncWithSelectorGivesTheSameResultAsMinForNullableAsyn => (Option.FromNullable(sequence.Select(selector).MinAsync().Result) == sequence.Select(Option.FromNullable).MinOrNoneAsync(SelectorTransformation.TransformNullableSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property MinOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsMinForNullableAsyncForDecimal(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select((decimal? item, CancellationToken _) => selector.Get(item)).MinAsync().Result) - == sequence.Select(Option.FromNullable).MinOrNoneAwaitAsync(SelectorTransformation.TransformNullableSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property MinOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsMinForNullableAsyncForDecimal(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(selector.Get).MinAsync().Result) @@ -150,11 +124,6 @@ public Property MinOrNoneAsyncWithSelectorGivesTheSameResultAsMinForNullableAsyn => (Option.FromNullable(sequence.Select(Person.Create).Select(SelectorTransformation.TransformPersonSelector(selector)).MinAsync().Result) == sequence.Select(Person.Create).Select(Option.FromNullable).MinOrNoneAsync(SelectorTransformation.TransformOptionPersonSelector(selector)).Result).ToProperty(); - [FunckyAsyncProperty] - public Property MinOrNoneAwaitAsyncWithSelectorGivesTheSameResultAsMinForNullableAsyncForAnyIComparable(IAsyncEnumerable sequence, AwaitSelector selector) - => (Option.FromNullable(sequence.Select(Person.Create).Select((Person? person, CancellationToken _) => SelectorTransformation.TransformPersonSelector(selector.Get)(person)).MinAsync().Result) - == sequence.Select(Person.Create).Select(Option.FromNullable).MinOrNoneAwaitAsync(SelectorTransformation.TransformOptionPersonSelector(selector.Get)).Result).ToProperty(); - [FunckyAsyncProperty] public Property MinOrNoneAsyncWithAsyncSelectorGivesTheSameResultAsMinForNullableAsyncForAnyIComparable(IAsyncEnumerable sequence, AwaitSelectorWithCancellation selector) => (Option.FromNullable(sequence.Select(Person.Create).Select(SelectorTransformation.TransformPersonSelector(selector.Get)).MinAsync().Result) diff --git a/Funcky.Test/Extensions/AsyncEnumerableExtensions/PartitionTest.cs b/Funcky.Test/Extensions/AsyncEnumerableExtensions/PartitionTest.cs index 29952e7d6..973723387 100644 --- a/Funcky.Test/Extensions/AsyncEnumerableExtensions/PartitionTest.cs +++ b/Funcky.Test/Extensions/AsyncEnumerableExtensions/PartitionTest.cs @@ -1,4 +1,3 @@ -#pragma warning disable CS0618 // PartitionAwaitAsync is obsolete but keeps working until 4.0.0. #if ASYNC_SUPPORTED namespace Funcky.Async.Test.Extensions.AsyncEnumerableExtensions; @@ -20,22 +19,6 @@ public async Task PartitionsItemsIntoTruesAndFalses() Assert.Equal([1, 3, 5], odds); } - [Fact] - public async Task PartitionsItemsIntoTruesAndFalsesWithAsyncPredicate() - { - var (evens, odds) = await AsyncEnumerable.Range(0, 6).PartitionAwaitAsync(x => ValueTask.FromResult(IsEven(x))); - Assert.Equal([0, 2, 4], evens); - Assert.Equal([1, 3, 5], odds); - } - - [Fact] - public async Task PartitionsItemsIntoTruesAndFalsesWithAsyncCancellablePredicate() - { - var (evens, odds) = await AsyncEnumerable.Range(0, 6).PartitionAwaitWithCancellationAsync((x, _) => ValueTask.FromResult(IsEven(x))); - Assert.Equal([0, 2, 4], evens); - Assert.Equal([1, 3, 5], odds); - } - [Fact] public async Task RightItemsAreEmptyWhenPredicateMatchesAllItems() { diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupBy.ValueTask.cs b/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupBy.ValueTask.cs index 7995fc6a0..7fb339cac 100644 --- a/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupBy.ValueTask.cs +++ b/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupBy.ValueTask.cs @@ -13,11 +13,7 @@ public static partial class AsyncEnumerableExtensions /// [Pure] [OverloadResolutionPriority(1)] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupBy( -#else public static IAsyncEnumerable> AdjacentGroupBy( -#endif this IAsyncEnumerable source, Func> keySelector) => AdjacentGroupByAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ValueTaskFromResult, CreateGroupingAwait, EqualityComparer.Default); @@ -25,11 +21,7 @@ public static IAsyncEnumerable> AdjacentGroupBy [Pure] [OverloadResolutionPriority(1)] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupBy( -#else public static IAsyncEnumerable> AdjacentGroupBy( -#endif this IAsyncEnumerable source, Func> keySelector, IEqualityComparer comparer) @@ -38,11 +30,7 @@ public static IAsyncEnumerable> AdjacentGroupBy [Pure] [OverloadResolutionPriority(1)] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupBy( -#else public static IAsyncEnumerable> AdjacentGroupBy( -#endif this IAsyncEnumerable source, Func> keySelector, Func> elementSelector) @@ -51,11 +39,7 @@ public static IAsyncEnumerable> AdjacentGroupBy [Pure] [OverloadResolutionPriority(1)] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupBy( -#else public static IAsyncEnumerable> AdjacentGroupBy( -#endif this IAsyncEnumerable source, Func> keySelector, Func> elementSelector, @@ -101,5 +85,57 @@ public static IAsyncEnumerable AdjacentGroupBy, CancellationToken, ValueTask> resultSelector, IEqualityComparer comparer) => AdjacentGroupByAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ArgumentValidator.NotNull(elementSelector), ArgumentValidator.NotNull(resultSelector), ArgumentValidator.NotNull(comparer)); + + private static async IAsyncEnumerable AdjacentGroupByAwaitWithCancellationInternal( + this IAsyncEnumerable source, + Func> keySelector, + Func> elementSelector, + Func, CancellationToken, ValueTask> resultSelector, + IEqualityComparer comparer, + [EnumeratorCancellation] CancellationToken cancellationToken = default) + { + var asyncEnumerator = source.GetAsyncEnumerator(cancellationToken); + await using var sourceEnumerator = asyncEnumerator.ConfigureAwait(false); + + if (!await asyncEnumerator.MoveNextAsync().ConfigureAwait(false)) + { + yield break; + } + + var (group, key) = await CreateGroupAndKeyAsync(keySelector, elementSelector, asyncEnumerator, cancellationToken).ConfigureAwait(false); + + while (await asyncEnumerator.MoveNextAsync().ConfigureAwait(false)) + { + if (comparer.Equals(key, await keySelector(asyncEnumerator.Current, cancellationToken).ConfigureAwait(false))) + { + group = group.Add(await elementSelector(asyncEnumerator.Current, cancellationToken).ConfigureAwait(false)); + } + else + { + yield return await resultSelector(key, group, cancellationToken).ConfigureAwait(false); + (group, key) = await CreateGroupAndKeyAsync(keySelector, elementSelector, asyncEnumerator, cancellationToken).ConfigureAwait(false); + } + } + + yield return await resultSelector(key, group, cancellationToken).ConfigureAwait(false); + } + + private static ValueTask> CreateGroupingAwait( + TKey key, + IImmutableList elements, + CancellationToken cancellationToken) + => ValueTaskFromResult(new Grouping(key, elements), cancellationToken); + + private static async Task<(IImmutableList Group, TKey Key)> CreateGroupAndKeyAsync( + Func> keySelector, + Func> elementSelector, + IAsyncEnumerator enumerator, + CancellationToken cancellationToken) + { + var group = ImmutableList.Create(await elementSelector(enumerator.Current, cancellationToken).ConfigureAwait(false)); + var key = await keySelector(enumerator.Current, cancellationToken).ConfigureAwait(false); + + return (group, key); + } } #endif diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupBy.cs b/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupBy.cs index 2b072083d..938621d62 100644 --- a/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupBy.cs +++ b/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupBy.cs @@ -16,11 +16,7 @@ public static partial class AsyncEnumerableExtensions /// A function to extract the key for each element. /// An where each element is an object containing a sequence of objects and a key. [Pure] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupBy( -#else public static IAsyncEnumerable> AdjacentGroupBy( -#endif this IAsyncEnumerable source, Func keySelector) => AdjacentGroupByInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), Identity, CreateGrouping, EqualityComparer.Default); @@ -35,11 +31,7 @@ public static IAsyncEnumerable> AdjacentGroupByAn to compare keys. /// An where each element is an object containing a sequence of objects and a key. [Pure] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupBy( -#else public static IAsyncEnumerable> AdjacentGroupBy( -#endif this IAsyncEnumerable source, Func keySelector, IEqualityComparer comparer) @@ -56,11 +48,7 @@ public static IAsyncEnumerable> AdjacentGroupByA function to map each source element to an element in the . /// An where each element is an object containing a sequence of objects and a key. [Pure] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupBy( -#else public static IAsyncEnumerable> AdjacentGroupBy( -#endif this IAsyncEnumerable source, Func keySelector, Func elementSelector) @@ -78,11 +66,7 @@ public static IAsyncEnumerable> AdjacentGroupByAn to compare keys. /// An where each element is an object containing a sequence of objects and a key. [Pure] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupBy( -#else public static IAsyncEnumerable> AdjacentGroupBy( -#endif this IAsyncEnumerable source, Func keySelector, Func elementSelector, @@ -201,13 +185,8 @@ private static async IAsyncEnumerable AdjacentGroupByInternal CreateGrouping(TKey key, IImmutableList elements) - => new(key, elements); -#else private static Grouping CreateGrouping(TKey key, IImmutableList elements) => new(key, elements); -#endif private static (IImmutableList Group, TKey Key) CreateGroupAndKey(Func keySelector, Func elementSelector, IAsyncEnumerator enumerator) { diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupByAwait.cs b/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupByAwait.cs deleted file mode 100644 index 41e0cfbc5..000000000 --- a/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupByAwait.cs +++ /dev/null @@ -1,229 +0,0 @@ -#if ASYNC_SUPPORTED -using System.Collections.Immutable; -using System.Runtime.CompilerServices; -using Funcky.Internal.Validators; -using static Funcky.ValueTaskFactory; - -namespace Funcky.Extensions; - -public static partial class AsyncEnumerableExtensions -{ - /// - /// Groups adjacent elements of a source sequence with same key specified by the key selector function. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The source sequence. - /// A function to extract the key for each element. - /// An where each element is an object containing a sequence of objects and a key. - [Pure] - [Obsolete("Use AdjacentGroupBy with (item, cancellationToken) selectors instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupByAwait( -#else - public static IAsyncEnumerable> AdjacentGroupByAwait( -#endif - this IAsyncEnumerable source, - Func> keySelector) - => AdjacentGroupByAwaitInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ValueTaskFromResult, CreateGroupingAwait, EqualityComparer.Default); - - /// - /// Groups adjacent elements of a source sequence according to a specified key selector function and compares the keys by using a specified comparer. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The source sequence. - /// A function to extract the key for each element. - /// An IEqualityComparer{T} to compare keys. - /// An where each element is an object containing a sequence of objects and a key. - [Pure] - [Obsolete("Use AdjacentGroupBy with (item, cancellationToken) selectors instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupByAwait( -#else - public static IAsyncEnumerable> AdjacentGroupByAwait( -#endif - this IAsyncEnumerable source, - Func> keySelector, - IEqualityComparer comparer) - => AdjacentGroupByAwaitInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ValueTaskFromResult, CreateGroupingAwait, ArgumentValidator.NotNull(comparer)); - - /// - /// Groups adjacent elements of a source sequence according to a key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The type of the elements in each . - /// The source sequence. - /// A function to extract the key for each element. - /// A function to map each source element to an element in the . - /// An where each element is an object containing a sequence of objects and a key. - [Pure] - [Obsolete("Use AdjacentGroupBy with (item, cancellationToken) selectors instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupByAwait( -#else - public static IAsyncEnumerable> AdjacentGroupByAwait( -#endif - this IAsyncEnumerable source, - Func> keySelector, - Func> elementSelector) - => AdjacentGroupByAwaitInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ArgumentValidator.NotNull(elementSelector), CreateGroupingAwait, EqualityComparer.Default); - - /// - /// Groups adjacent elements of a source sequence according to a specified key selector function and projects the elements for each group by using a specified function. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The type of the elements in each . - /// The source sequence. - /// A function to extract the key for each element. - /// A function to map each source element to an element in the . - /// An IEqualityComparer{T} to compare keys. - /// An where each element is an object containing a sequence of objects and a key. - [Pure] - [Obsolete("Use AdjacentGroupBy with (item, cancellationToken) selectors instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupByAwait( -#else - public static IAsyncEnumerable> AdjacentGroupByAwait( -#endif - this IAsyncEnumerable source, - Func> keySelector, - Func> elementSelector, - IEqualityComparer comparer) - => AdjacentGroupByAwaitInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ArgumentValidator.NotNull(elementSelector), CreateGroupingAwait, ArgumentValidator.NotNull(comparer)); - - /// - /// Groups adjacent elements of a source sequence according to a specified key selector function and creates a result value from each group and its key. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The type of the result value returned by resultSelector. - /// The source sequence. - /// A function to extract the key for each element. - /// A function to map each source element to an element in the . - /// A collection of elements of type TResult where each element represents a projection over a group and its key. - [Pure] - [Obsolete("Use AdjacentGroupBy with (item, cancellationToken) selectors instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public static IAsyncEnumerable AdjacentGroupByAwait( - this IAsyncEnumerable source, - Func> keySelector, - Func, ValueTask> resultSelector) - => AdjacentGroupByAwaitInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ValueTaskFromResult, ArgumentValidator.NotNull(resultSelector), EqualityComparer.Default); - - /// - /// Groups adjacent elements of a source sequence according to a specified key selector function and creates a result value from each group and its key. The elements of each group are projected by using a specified function. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The type of the elements in each . - /// The type of the result value returned by resultSelector. - /// The source sequence. - /// A function to extract the key for each element. - /// A function to map each source element to an element in the . - /// A function to create a result value from each group. - /// A collection of elements of type TResult where each element represents a projection over a group and its key. - [Pure] - [Obsolete("Use AdjacentGroupBy with (item, cancellationToken) selectors instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public static IAsyncEnumerable AdjacentGroupByAwait( - this IAsyncEnumerable source, - Func> keySelector, - Func> elementSelector, - Func, ValueTask> resultSelector) - => AdjacentGroupByAwaitInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ArgumentValidator.NotNull(elementSelector), ArgumentValidator.NotNull(resultSelector), EqualityComparer.Default); - - /// - /// Groups adjacent elements of a source sequence according to a specified key selector function and creates a result value from each group and its key. The keys are compared by using a specified comparer. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The type of the result value returned by resultSelector. - /// The source sequence. - /// A function to extract the key for each element. - /// A function to create a result value from each group. - /// An IEqualityComparer{T} to compare keys. - /// A collection of elements of type TResult where each element represents a projection over a group and its key. - [Pure] - [Obsolete("Use AdjacentGroupBy with (item, cancellationToken) selectors instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public static IAsyncEnumerable AdjacentGroupByAwait( - this IAsyncEnumerable source, - Func> keySelector, - Func, ValueTask> resultSelector, - IEqualityComparer comparer) - => AdjacentGroupByAwaitInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ValueTaskFromResult, ArgumentValidator.NotNull(resultSelector), ArgumentValidator.NotNull(comparer)); - - /// - /// Groups adjacent elements of a source sequence according to a specified key selector function and creates a result value from each group and its key. Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The type of the elements in each . - /// The type of the result value returned by resultSelector. - /// The source sequence. - /// A function to extract the key for each element. - /// A function to map each source element to an element in the . - /// A function to create a result value from each group. - /// An IEqualityComparer{T} to compare keys. - /// A collection of elements of type TResult where each element represents a projection over a group and its key. - [Pure] - [Obsolete("Use AdjacentGroupBy with (item, cancellationToken) selectors instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public static IAsyncEnumerable AdjacentGroupByAwait( - this IAsyncEnumerable source, - Func> keySelector, - Func> elementSelector, - Func, ValueTask> resultSelector, - IEqualityComparer comparer) - => AdjacentGroupByAwaitInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ArgumentValidator.NotNull(elementSelector), ArgumentValidator.NotNull(resultSelector), ArgumentValidator.NotNull(comparer)); - - private static async IAsyncEnumerable AdjacentGroupByAwaitInternal( - this IAsyncEnumerable source, - Func> keySelector, - Func> elementSelector, - Func, ValueTask> resultSelector, - IEqualityComparer comparer, - [EnumeratorCancellation] CancellationToken cancellationToken = default) - { - var asyncEnumerator = source.GetAsyncEnumerator(cancellationToken); - await using var sourceEnumerator = asyncEnumerator.ConfigureAwait(false); - - if (!await asyncEnumerator.MoveNextAsync().ConfigureAwait(false)) - { - yield break; - } - - var (group, key) = await CreateGroupAndKeyAsync(keySelector, elementSelector, asyncEnumerator).ConfigureAwait(false); - - while (await asyncEnumerator.MoveNextAsync().ConfigureAwait(false)) - { - if (comparer.Equals(key, await keySelector(asyncEnumerator.Current).ConfigureAwait(false))) - { - group = group.Add(await elementSelector(asyncEnumerator.Current).ConfigureAwait(false)); - } - else - { - yield return await resultSelector(key, group).ConfigureAwait(false); - (group, key) = await CreateGroupAndKeyAsync(keySelector, elementSelector, asyncEnumerator).ConfigureAwait(false); - } - } - - yield return await resultSelector(key, group).ConfigureAwait(false); - } - -#if SYSTEM_LINQ_ASYNC - private static ValueTask> CreateGroupingAwait(TKey key, IImmutableList elements) - => ValueTaskFromResult(new AsyncGrouping(key, elements)); -#else - private static ValueTask> CreateGroupingAwait(TKey key, IImmutableList elements) - => ValueTaskFromResult(new Grouping(key, elements)); -#endif - - private static async Task<(IImmutableList Group, TKey Key)> CreateGroupAndKeyAsync(Func> keySelector, Func> elementSelector, IAsyncEnumerator enumerator) - { - var group = ImmutableList.Create(await elementSelector(enumerator.Current).ConfigureAwait(false)); - var key = await keySelector(enumerator.Current).ConfigureAwait(false); - - return (group, key); - } -} -#endif diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupByAwaitWithCancellation.cs b/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupByAwaitWithCancellation.cs deleted file mode 100644 index 909bacccb..000000000 --- a/Funcky/Extensions/AsyncEnumerableExtensions/AdjacentGroupByAwaitWithCancellation.cs +++ /dev/null @@ -1,239 +0,0 @@ -#if ASYNC_SUPPORTED -using System.Collections.Immutable; -using System.Runtime.CompilerServices; -using Funcky.Internal.Validators; -using static Funcky.ValueTaskFactory; - -namespace Funcky.Extensions; - -public static partial class AsyncEnumerableExtensions -{ - /// - /// Groups adjacent elements of a source sequence with same key specified by the key selector function. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The source sequence. - /// A function to extract the key for each element. - /// An where each element is an object containing a sequence of objects and a key. - [Pure] - [Obsolete("Use AdjacentGroupBy instead, which takes the same selectors. This method will be removed in Funcky 4.0.0.")] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupByAwaitWithCancellation( -#else - public static IAsyncEnumerable> AdjacentGroupByAwaitWithCancellation( -#endif - this IAsyncEnumerable source, - Func> keySelector) - => AdjacentGroupByAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ValueTaskFromResult, CreateGroupingAwait, EqualityComparer.Default); - - /// - /// Groups adjacent elements of a source sequence according to a specified key selector function and compares the keys by using a specified comparer. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The source sequence. - /// A function to extract the key for each element. - /// An IEqualityComparer{T} to compare keys. - /// An where each element is an object containing a sequence of objects and a key. - [Pure] - [Obsolete("Use AdjacentGroupBy instead, which takes the same selectors. This method will be removed in Funcky 4.0.0.")] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupByAwaitWithCancellation( -#else - public static IAsyncEnumerable> AdjacentGroupByAwaitWithCancellation( -#endif - this IAsyncEnumerable source, - Func> keySelector, - IEqualityComparer comparer) - => AdjacentGroupByAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ValueTaskFromResult, CreateGroupingAwait, ArgumentValidator.NotNull(comparer)); - - /// - /// Groups adjacent elements of a source sequence according to a key selector function. The keys are compared by using a comparer and each group's elements are projected by using a specified function. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The type of the elements in each . - /// The source sequence. - /// A function to extract the key for each element. - /// A function to map each source element to an element in the . - /// An where each element is an object containing a sequence of objects and a key. - [Pure] - [Obsolete("Use AdjacentGroupBy instead, which takes the same selectors. This method will be removed in Funcky 4.0.0.")] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupByAwaitWithCancellation( -#else - public static IAsyncEnumerable> AdjacentGroupByAwaitWithCancellation( -#endif - this IAsyncEnumerable source, - Func> keySelector, - Func> elementSelector) - => AdjacentGroupByAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ArgumentValidator.NotNull(elementSelector), CreateGroupingAwait, EqualityComparer.Default); - - /// - /// Groups adjacent elements of a source sequence according to a specified key selector function and projects the elements for each group by using a specified function. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The type of the elements in each . - /// The source sequence. - /// A function to extract the key for each element. - /// A function to map each source element to an element in the . - /// An IEqualityComparer{T} to compare keys. - /// An where each element is an object containing a sequence of objects and a key. - [Pure] - [Obsolete("Use AdjacentGroupBy instead, which takes the same selectors. This method will be removed in Funcky 4.0.0.")] -#if SYSTEM_LINQ_ASYNC - public static IAsyncEnumerable> AdjacentGroupByAwaitWithCancellation( -#else - public static IAsyncEnumerable> AdjacentGroupByAwaitWithCancellation( -#endif - this IAsyncEnumerable source, - Func> keySelector, - Func> elementSelector, - IEqualityComparer comparer) - => AdjacentGroupByAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ArgumentValidator.NotNull(elementSelector), CreateGroupingAwait, ArgumentValidator.NotNull(comparer)); - - /// - /// Groups adjacent elements of a source sequence according to a specified key selector function and creates a result value from each group and its key. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The type of the result value returned by resultSelector. - /// The source sequence. - /// A function to extract the key for each element. - /// A function to map each source element to an element in the . - /// A collection of elements of type TResult where each element represents a projection over a group and its key. - [Pure] - [Obsolete("Use AdjacentGroupBy instead, which takes the same selectors. This method will be removed in Funcky 4.0.0.")] - public static IAsyncEnumerable AdjacentGroupByAwaitWithCancellation( - this IAsyncEnumerable source, - Func> keySelector, - Func, CancellationToken, ValueTask> resultSelector) - => AdjacentGroupByAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ValueTaskFromResult, ArgumentValidator.NotNull(resultSelector), EqualityComparer.Default); - - /// - /// Groups adjacent elements of a source sequence according to a specified key selector function and creates a result value from each group and its key. The elements of each group are projected by using a specified function. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The type of the elements in each . - /// The type of the result value returned by resultSelector. - /// The source sequence. - /// A function to extract the key for each element. - /// A function to map each source element to an element in the . - /// A function to create a result value from each group. - /// A collection of elements of type TResult where each element represents a projection over a group and its key. - [Pure] - [Obsolete("Use AdjacentGroupBy instead, which takes the same selectors. This method will be removed in Funcky 4.0.0.")] - public static IAsyncEnumerable AdjacentGroupByAwaitWithCancellation( - this IAsyncEnumerable source, - Func> keySelector, - Func> elementSelector, - Func, CancellationToken, ValueTask> resultSelector) - => AdjacentGroupByAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ArgumentValidator.NotNull(elementSelector), ArgumentValidator.NotNull(resultSelector), EqualityComparer.Default); - - /// - /// Groups adjacent elements of a source sequence according to a specified key selector function and creates a result value from each group and its key. The keys are compared by using a specified comparer. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The type of the result value returned by resultSelector. - /// The source sequence. - /// A function to extract the key for each element. - /// A function to create a result value from each group. - /// An IEqualityComparer{T} to compare keys. - /// A collection of elements of type TResult where each element represents a projection over a group and its key. - [Pure] - [Obsolete("Use AdjacentGroupBy instead, which takes the same selectors. This method will be removed in Funcky 4.0.0.")] - public static IAsyncEnumerable AdjacentGroupByAwaitWithCancellation( - this IAsyncEnumerable source, - Func> keySelector, - Func, CancellationToken, ValueTask> resultSelector, - IEqualityComparer comparer) - => AdjacentGroupByAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ValueTaskFromResult, ArgumentValidator.NotNull(resultSelector), ArgumentValidator.NotNull(comparer)); - - /// - /// Groups adjacent elements of a source sequence according to a specified key selector function and creates a result value from each group and its key. Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function. - /// - /// Type of the elements in sequence. - /// The type of the key returned by keySelector. - /// The type of the elements in each . - /// The type of the result value returned by resultSelector. - /// The source sequence. - /// A function to extract the key for each element. - /// A function to map each source element to an element in the . - /// A function to create a result value from each group. - /// An IEqualityComparer{T} to compare keys. - /// A collection of elements of type TResult where each element represents a projection over a group and its key. - [Pure] - [Obsolete("Use AdjacentGroupBy instead, which takes the same selectors. This method will be removed in Funcky 4.0.0.")] - public static IAsyncEnumerable AdjacentGroupByAwaitWithCancellation( - this IAsyncEnumerable source, - Func> keySelector, - Func> elementSelector, - Func, CancellationToken, ValueTask> resultSelector, - IEqualityComparer comparer) - => AdjacentGroupByAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(keySelector), ArgumentValidator.NotNull(elementSelector), ArgumentValidator.NotNull(resultSelector), ArgumentValidator.NotNull(comparer)); - - private static async IAsyncEnumerable AdjacentGroupByAwaitWithCancellationInternal( - this IAsyncEnumerable source, - Func> keySelector, - Func> elementSelector, - Func, CancellationToken, ValueTask> resultSelector, - IEqualityComparer comparer, - [EnumeratorCancellation] CancellationToken cancellationToken = default) - { - var asyncEnumerator = source.GetAsyncEnumerator(cancellationToken); - await using var sourceEnumerator = asyncEnumerator.ConfigureAwait(false); - - if (!await asyncEnumerator.MoveNextAsync().ConfigureAwait(false)) - { - yield break; - } - - var (group, key) = await CreateGroupAndKeyAsync(keySelector, elementSelector, asyncEnumerator, cancellationToken).ConfigureAwait(false); - - while (await asyncEnumerator.MoveNextAsync().ConfigureAwait(false)) - { - if (comparer.Equals(key, await keySelector(asyncEnumerator.Current, cancellationToken).ConfigureAwait(false))) - { - group = group.Add(await elementSelector(asyncEnumerator.Current, cancellationToken).ConfigureAwait(false)); - } - else - { - yield return await resultSelector(key, group, cancellationToken).ConfigureAwait(false); - (group, key) = await CreateGroupAndKeyAsync(keySelector, elementSelector, asyncEnumerator, cancellationToken).ConfigureAwait(false); - } - } - - yield return await resultSelector(key, group, cancellationToken).ConfigureAwait(false); - } - -#if SYSTEM_LINQ_ASYNC - private static ValueTask> CreateGroupingAwait( - TKey key, - IImmutableList elements, - CancellationToken cancellationToken) - => ValueTaskFromResult(new AsyncGrouping(key, elements), cancellationToken); -#else - private static ValueTask> CreateGroupingAwait( - TKey key, - IImmutableList elements, - CancellationToken cancellationToken) - => ValueTaskFromResult(new Grouping(key, elements), cancellationToken); -#endif - - private static async Task<(IImmutableList Group, TKey Key)> CreateGroupAndKeyAsync( - Func> keySelector, - Func> elementSelector, - IAsyncEnumerator enumerator, - CancellationToken cancellationToken) - { - var group = ImmutableList.Create(await elementSelector(enumerator.Current, cancellationToken).ConfigureAwait(false)); - var key = await keySelector(enumerator.Current, cancellationToken).ConfigureAwait(false); - - return (group, key); - } -} -#endif diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/AverageOrNoneAwait.cs b/Funcky/Extensions/AsyncEnumerableExtensions/AverageOrNoneAwait.cs deleted file mode 100644 index 326adcb05..000000000 --- a/Funcky/Extensions/AsyncEnumerableExtensions/AverageOrNoneAwait.cs +++ /dev/null @@ -1,312 +0,0 @@ -#if ASYNC_SUPPORTED -namespace Funcky.Extensions; - -public static partial class AsyncEnumerableExtensions -{ - /// A sequence of values that are used to calculate an average. - /// The type of the elements of source. - extension(IAsyncEnumerable source) - { - /// - /// Computes the average of a sequence of values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence is empty it returns None. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitAsync(Func> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync((element, _) => selector(element), cancellationToken); - - /// - /// Computes the average of a sequence of optional values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence only consists of none or is empty it returns None. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitAsync(Func>> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync((element, _) => selector(element), cancellationToken); - - /// - /// Computes the average of a sequence of values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence is empty it returns None. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitAsync(Func> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync((element, _) => selector(element), cancellationToken); - - /// - /// Computes the average of a sequence of optional values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence only consists of none or is empty it returns None. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitAsync(Func>> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync((element, _) => selector(element), cancellationToken); - - /// - /// Computes the average of a sequence of values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence is empty it returns None. - /// The rules for floating point arithmetic apply see remarks for detail. - /// - /// - /// Any sequence containing at least one NaN value will evaluate to NaN. - /// A sequence containing at least one +Infinity will always evaluate to an average of +infinity. - /// A sequence containing at least one -Infinity will always evaluate to an average of -infinity. - /// A sequence containing at least one of each +Infinity and -Infinity values will always evaluate to NaN. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitAsync(Func> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync((element, _) => selector(element), cancellationToken); - - /// - /// Computes the average of a sequence of optional values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence only consists of none or is empty it returns None. - /// The rules for floating point arithmetic apply see remarks for detail. - /// - /// - /// Any sequence containing at least one NaN value will evaluate to NaN. - /// A sequence containing at least one +Infinity will always evaluate to an average of +infinity. - /// A sequence containing at least one -Infinity will always evaluate to an average of -infinity. - /// A sequence containing at least one of each +Infinity and -Infinity values will always evaluate to NaN. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitAsync(Func>> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync((element, _) => selector(element), cancellationToken); - - /// - /// Computes the average of a sequence of values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence is empty it returns None. - /// The rules for floating point arithmetic apply see remarks for detail. - /// - /// - /// Any sequence containing at least one NaN value will evaluate to NaN. - /// A sequence containing at least one +Infinity will always evaluate to an average of +infinity. - /// A sequence containing at least one -Infinity will always evaluate to an average of -infinity. - /// A sequence containing at least one of each +Infinity and -Infinity values will always evaluate to NaN. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitAsync(Func> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync((element, _) => selector(element), cancellationToken); - - /// - /// Computes the average of a sequence of optional values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence only consists of none or is empty it returns None. - /// The rules for floating point arithmetic apply see remarks for detail. - /// - /// - /// Any sequence containing at least one NaN value will evaluate to NaN. - /// A sequence containing at least one +Infinity will always evaluate to an average of +infinity. - /// A sequence containing at least one -Infinity will always evaluate to an average of -infinity. - /// A sequence containing at least one of each +Infinity and -Infinity values will always evaluate to NaN. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitAsync(Func>> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync((element, _) => selector(element), cancellationToken); - - /// - /// Computes the average of a sequence of values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence is empty it returns None. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitAsync(Func> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync((element, _) => selector(element), cancellationToken); - - /// - /// Computes the average of a sequence of optional values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence only consists of none or is empty it returns None. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitAsync(Func>> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync((element, _) => selector(element), cancellationToken); - } - - /// A sequence of values that are used to calculate an average. - /// The type of the elements of source. - extension(IAsyncEnumerable source) - { - /// - /// Computes the average of a sequence of values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence is empty it returns None. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitWithCancellationAsync(Func> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync(selector, cancellationToken); - - /// - /// Computes the average of a sequence of optional values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence only consists of none or is empty it returns None. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitWithCancellationAsync(Func>> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync(selector, cancellationToken); - - /// - /// Computes the average of a sequence of values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence is empty it returns None. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitWithCancellationAsync(Func> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync(selector, cancellationToken); - - /// - /// Computes the average of a sequence of optional values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence only consists of none or is empty it returns None. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitWithCancellationAsync(Func>> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync(selector, cancellationToken); - - /// - /// Computes the average of a sequence of values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence is empty it returns None. - /// The rules for floating point arithmetic apply see remarks for detail. - /// - /// - /// Any sequence containing at least one NaN value will evaluate to NaN. - /// A sequence containing at least one +Infinity will always evaluate to an average of +infinity. - /// A sequence containing at least one -Infinity will always evaluate to an average of -infinity. - /// A sequence containing at least one of each +Infinity and -Infinity values will always evaluate to NaN. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitWithCancellationAsync(Func> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync(selector, cancellationToken); - - /// - /// Computes the average of a sequence of optional values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence only consists of none or is empty it returns None. - /// The rules for floating point arithmetic apply see remarks for detail. - /// - /// - /// Any sequence containing at least one NaN value will evaluate to NaN. - /// A sequence containing at least one +Infinity will always evaluate to an average of +infinity. - /// A sequence containing at least one -Infinity will always evaluate to an average of -infinity. - /// A sequence containing at least one of each +Infinity and -Infinity values will always evaluate to NaN. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitWithCancellationAsync(Func>> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync(selector, cancellationToken); - - /// - /// Computes the average of a sequence of values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence is empty it returns None. - /// The rules for floating point arithmetic apply see remarks for detail. - /// - /// - /// Any sequence containing at least one NaN value will evaluate to NaN. - /// A sequence containing at least one +Infinity will always evaluate to an average of +infinity. - /// A sequence containing at least one -Infinity will always evaluate to an average of -infinity. - /// A sequence containing at least one of each +Infinity and -Infinity values will always evaluate to NaN. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitWithCancellationAsync(Func> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync(selector, cancellationToken); - - /// - /// Computes the average of a sequence of optional values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence only consists of none or is empty it returns None. - /// The rules for floating point arithmetic apply see remarks for detail. - /// - /// - /// Any sequence containing at least one NaN value will evaluate to NaN. - /// A sequence containing at least one +Infinity will always evaluate to an average of +infinity. - /// A sequence containing at least one -Infinity will always evaluate to an average of -infinity. - /// A sequence containing at least one of each +Infinity and -Infinity values will always evaluate to NaN. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitWithCancellationAsync(Func>> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync(selector, cancellationToken); - - /// - /// Computes the average of a sequence of values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence is empty it returns None. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitWithCancellationAsync(Func> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync(selector, cancellationToken); - - /// - /// Computes the average of a sequence of optional values that are obtained by invoking a transform function on each element of the input sequence of . - /// If the sequence only consists of none or is empty it returns None. - /// - /// A transform function to apply to each element. - /// A cancellation token. - /// The average of the sequence of values or None. - [Pure] - [Obsolete("Use AverageOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> AverageOrNoneAwaitWithCancellationAsync(Func>> selector, CancellationToken cancellationToken = default) - => source.AverageOrNoneAsync(selector, cancellationToken); - } -} -#endif diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/Chunk.cs b/Funcky/Extensions/AsyncEnumerableExtensions/Chunk.cs index a0196be46..615135e97 100644 --- a/Funcky/Extensions/AsyncEnumerableExtensions/Chunk.cs +++ b/Funcky/Extensions/AsyncEnumerableExtensions/Chunk.cs @@ -6,22 +6,6 @@ namespace Funcky.Extensions; public static partial class AsyncEnumerableExtensions { -#if SYSTEM_LINQ_ASYNC - /// The source sequence. - /// Type of the elements in sequence. - extension(IAsyncEnumerable source) - { - /// - /// Chunks the source sequence into equally sized chunks. The last chunk can be smaller. - /// - /// The desired size of the chunks. - /// A sequence of equally sized sequences containing elements of the source collection in the same order. - /// Starting with .NET 10 the base class library provides this overload itself, so it is only part of Funcky.Async. - [Pure] - public IAsyncEnumerable> Chunk(int size) - => ChunkEnumerable(ArgumentValidator.NotNull(source), ChunkSizeValidator.Validate(size)); - } -#endif /// The source sequence. /// Type of the elements in sequence. extension(IAsyncEnumerable source) @@ -50,25 +34,8 @@ public IAsyncEnumerable Chunk(int size, Func Chunk(int size, Func, CancellationToken, ValueTask> resultSelector) => ChunkEnumerable(ArgumentValidator.NotNull(source), ChunkSizeValidator.Validate(size)) .Select(ArgumentValidator.NotNull(resultSelector)); - - /// - [Pure] - [Obsolete("Use Chunk with a (chunk, cancellationToken) delegate instead; discard the token with (chunk, _) => …. This method will be removed in Funcky 4.0.0.")] - public IAsyncEnumerable ChunkAwait(int size, Func, ValueTask> resultSelector) - => ChunkEnumerable(ArgumentValidator.NotNull(source), ChunkSizeValidator.Validate(size)) - .Select(AwaitChunk(ArgumentValidator.NotNull(resultSelector))); - - /// - [Pure] - [Obsolete("Use Chunk instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public IAsyncEnumerable ChunkAwaitWithCancellation(int size, Func, CancellationToken, ValueTask> resultSelector) - => ChunkEnumerable(ArgumentValidator.NotNull(source), ChunkSizeValidator.Validate(size)) - .Select(ArgumentValidator.NotNull(resultSelector)); } - private static Func, CancellationToken, ValueTask> AwaitChunk(Func, ValueTask> resultSelector) - => (chunk, _) => resultSelector(chunk); - private static async IAsyncEnumerable> ChunkEnumerable(IAsyncEnumerable source, int size, [EnumeratorCancellation] CancellationToken cancellationToken = default) { var asyncEnumerator = source.GetAsyncEnumerator(cancellationToken); diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/FirstOrNone.cs b/Funcky/Extensions/AsyncEnumerableExtensions/FirstOrNone.cs index 6ed4651f1..af2442ec7 100644 --- a/Funcky/Extensions/AsyncEnumerableExtensions/FirstOrNone.cs +++ b/Funcky/Extensions/AsyncEnumerableExtensions/FirstOrNone.cs @@ -28,18 +28,6 @@ public async ValueTask> FirstOrNoneAsync(Func pre [Pure] public async ValueTask> FirstOrNoneAsync(Func> predicate, CancellationToken cancellationToken = default) => await source.Where(predicate).Select(Option.Some).FirstOrDefaultAsync(cancellationToken).ConfigureAwait(false); - - /// - [Pure] - [Obsolete("Use FirstOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> FirstOrNoneAwaitAsync(Func> predicate, CancellationToken cancellationToken = default) - => source.FirstOrNoneAsync((item, _) => predicate(item), cancellationToken); - - /// - [Pure] - [Obsolete("Use FirstOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> FirstOrNoneAwaitWithCancellationAsync(Func> predicate, CancellationToken cancellationToken = default) - => source.FirstOrNoneAsync(predicate, cancellationToken); } } #endif diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/Inspect.cs b/Funcky/Extensions/AsyncEnumerableExtensions/Inspect.cs index 6c0c25c42..7cb3b5216 100644 --- a/Funcky/Extensions/AsyncEnumerableExtensions/Inspect.cs +++ b/Funcky/Extensions/AsyncEnumerableExtensions/Inspect.cs @@ -31,28 +31,6 @@ public IAsyncEnumerable Inspect(Action inspector) public IAsyncEnumerable Inspect(Func inspector) => InspectAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(inspector)); - /// - /// An IEnumerable that calls and awaits the function on each element before yielding it. It can be used to encode side effects without enumerating. - /// The side effect will be executed whenever enumerating of the result happens. - /// - /// An asynchronous action. - /// Returns an with the side effect defined by action encoded in the enumerable. - [Pure] - [Obsolete("Use Inspect with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public IAsyncEnumerable InspectAwait(Func inspector) - => InspectAwaitInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(inspector)); - - /// - /// An IEnumerable that calls and awaits the function on each element before yielding it. It can be used to encode side effects without enumerating. - /// The side effect will be executed whenever enumerating of the result happens. - /// - /// An asynchronous action. - /// Returns an with the side effect defined by action encoded in the enumerable. - [Pure] - [Obsolete("Use Inspect instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public IAsyncEnumerable InspectAwaitWithCancellation(Func inspector) - => InspectAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(inspector)); - [MethodImpl(MethodImplOptions.AggressiveInlining)] private async IAsyncEnumerable InspectInternal( Action action, @@ -65,18 +43,6 @@ private async IAsyncEnumerable InspectInternal( } } - [MethodImpl(MethodImplOptions.AggressiveInlining)] - private async IAsyncEnumerable InspectAwaitInternal( - Func action, - [EnumeratorCancellation] CancellationToken cancellationToken = default) - { - await foreach (var item in source.ConfigureAwait(false).WithCancellation(cancellationToken)) - { - await action(item).ConfigureAwait(false); - yield return item; - } - } - [MethodImpl(MethodImplOptions.AggressiveInlining)] private async IAsyncEnumerable InspectAwaitWithCancellationInternal( Func action, diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/LastOrNone.cs b/Funcky/Extensions/AsyncEnumerableExtensions/LastOrNone.cs index da1e07048..5b5b93eb9 100644 --- a/Funcky/Extensions/AsyncEnumerableExtensions/LastOrNone.cs +++ b/Funcky/Extensions/AsyncEnumerableExtensions/LastOrNone.cs @@ -28,18 +28,6 @@ public async ValueTask> LastOrNoneAsync(Func pred [Pure] public async ValueTask> LastOrNoneAsync(Func> predicate, CancellationToken cancellationToken = default) => await source.Where(predicate).Select(Option.Some).LastOrDefaultAsync(cancellationToken).ConfigureAwait(false); - - /// - [Pure] - [Obsolete("Use LastOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> LastOrNoneAwaitAsync(Func> predicate, CancellationToken cancellationToken = default) - => source.LastOrNoneAsync((item, _) => predicate(item), cancellationToken); - - /// - [Pure] - [Obsolete("Use LastOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> LastOrNoneAwaitWithCancellationAsync(Func> predicate, CancellationToken cancellationToken = default) - => source.LastOrNoneAsync(predicate, cancellationToken); } } #endif diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/MaxOrNone.cs b/Funcky/Extensions/AsyncEnumerableExtensions/MaxOrNone.cs index e26733895..c2e81daf3 100644 --- a/Funcky/Extensions/AsyncEnumerableExtensions/MaxOrNone.cs +++ b/Funcky/Extensions/AsyncEnumerableExtensions/MaxOrNone.cs @@ -1,6 +1,5 @@ #if ASYNC_SUPPORTED using Funcky.Internal.Aggregators; -using Funcky.Internal.Validators; namespace Funcky.Extensions; @@ -51,19 +50,6 @@ public ValueTask> MaxOrNoneAsync(Func where TResult : notnull => source.Select(selector).AggregateAsync(Option.None, MaxAggregator.Aggregate, cancellationToken); - /// - /// Invokes a transform function on each element of a sequence and returns the maximum from the generic values compared by a . If the transformed sequence only consists of none or is empty it returns None. - /// - /// The type of the value returned by selector. - /// A transform function to apply to each element. - /// A cancellation token. - /// The maximum value in the sequence or None. - [Pure] - [Obsolete("Use MaxOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> MaxOrNoneAwaitAsync(Func> selector, CancellationToken cancellationToken = default) - where TResult : notnull - => source.MaxOrNoneAsync(IgnoringToken(ArgumentValidator.NotNull(selector)), cancellationToken); - /// /// Invokes a transform function on each element of a sequence and returns the maximum from the generic values compared by a . If the transformed sequence only consists of none or is empty it returns None. /// @@ -88,19 +74,6 @@ public ValueTask> MaxOrNoneAsync(Func source.WhereSelect(selector).MaxOrNoneAsync(Identity, cancellationToken); - /// - /// Invokes a transform function on each element of a sequence and returns the maximum from the optional generic values compared by a . If the transformed sequence only consists of none or is empty it returns None. - /// - /// The type of the value returned by selector. - /// A transform function to apply to each element. - /// A cancellation token. - /// The maximum value in the sequence or None. - [Pure] - [Obsolete("Use MaxOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> MaxOrNoneAwaitAsync(Func>> selector, CancellationToken cancellationToken = default) - where TResult : notnull - => source.MaxOrNoneAsync(IgnoringToken(ArgumentValidator.NotNull(selector)), cancellationToken); - /// /// Invokes a transform function on each element of a sequence and returns the maximum from the optional generic values compared by a . If the transformed sequence only consists of none or is empty it returns None. /// @@ -112,25 +85,6 @@ public ValueTask> MaxOrNoneAwaitAsync(Func> MaxOrNoneAsync(Func>> selector, CancellationToken cancellationToken = default) where TResult : notnull => source.WhereSelect(selector).MaxOrNoneAsync(Identity, cancellationToken); - - /// - [Pure] - [Obsolete("Use MaxOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> MaxOrNoneAwaitWithCancellationAsync(Func> selector, CancellationToken cancellationToken = default) - where TResult : notnull - => source.MaxOrNoneAsync(selector, cancellationToken); - - /// - [Pure] - [Obsolete("Use MaxOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> MaxOrNoneAwaitWithCancellationAsync(Func>> selector, CancellationToken cancellationToken = default) - where TResult : notnull - => source.MaxOrNoneAsync(selector, cancellationToken); } - - // Adapts a selector without token to the token-carrying overloads; the obsolete MaxOrNoneAwaitAsync and MinOrNoneAwaitAsync - // validate the selector before wrapping it, because the lambda would otherwise hide a null argument until the first element. - private static Func> IgnoringToken(Func> selector) - => (item, _) => selector(item); } #endif diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/MinOrNone.cs b/Funcky/Extensions/AsyncEnumerableExtensions/MinOrNone.cs index 4e5062541..06f81647e 100644 --- a/Funcky/Extensions/AsyncEnumerableExtensions/MinOrNone.cs +++ b/Funcky/Extensions/AsyncEnumerableExtensions/MinOrNone.cs @@ -1,6 +1,5 @@ #if ASYNC_SUPPORTED using Funcky.Internal.Aggregators; -using Funcky.Internal.Validators; namespace Funcky.Extensions; @@ -51,19 +50,6 @@ public ValueTask> MinOrNoneAsync(Func where TResult : notnull => source.Select(selector).AggregateAsync(Option.None, MinAggregator.Aggregate, cancellationToken); - /// - /// Invokes a transform function on each element of a sequence and returns the minimum from the generic values compared by a . If the transformed sequence only consists of none or is empty it returns None. - /// - /// The type of the value returned by selector. - /// A transform function to apply to each element. - /// A cancellation token. - /// The minimum value in the sequence or None. - [Pure] - [Obsolete("Use MinOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> MinOrNoneAwaitAsync(Func> selector, CancellationToken cancellationToken = default) - where TResult : notnull - => source.MinOrNoneAsync(IgnoringToken(ArgumentValidator.NotNull(selector)), cancellationToken); - /// /// Invokes a transform function on each element of a sequence and returns the minimum from the generic values compared by a . If the transformed sequence only consists of none or is empty it returns None. /// @@ -88,19 +74,6 @@ public ValueTask> MinOrNoneAsync(Func source.WhereSelect(selector).MinOrNoneAsync(Identity, cancellationToken); - /// - /// Invokes a transform function on each element of a sequence and returns the minimum from the generic values compared by a . If the transformed sequence only consists of none or is empty it returns None. - /// - /// The type of the value returned by selector. - /// A transform function to apply to each element. - /// A cancellation token. - /// The minimum value in the sequence or None. - [Pure] - [Obsolete("Use MinOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> MinOrNoneAwaitAsync(Func>> selector, CancellationToken cancellationToken = default) - where TResult : notnull - => source.MinOrNoneAsync(IgnoringToken(ArgumentValidator.NotNull(selector)), cancellationToken); - /// /// Invokes a transform function on each element of a sequence and returns the minimum from the optional generic values compared by a . If the transformed sequence only consists of none or is empty it returns None. /// @@ -112,20 +85,6 @@ public ValueTask> MinOrNoneAwaitAsync(Func> MinOrNoneAsync(Func>> selector, CancellationToken cancellationToken = default) where TResult : notnull => source.WhereSelect(selector).MinOrNoneAsync(Identity, cancellationToken); - - /// - [Pure] - [Obsolete("Use MinOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> MinOrNoneAwaitWithCancellationAsync(Func> selector, CancellationToken cancellationToken = default) - where TResult : notnull - => source.MinOrNoneAsync(selector, cancellationToken); - - /// - [Pure] - [Obsolete("Use MinOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> MinOrNoneAwaitWithCancellationAsync(Func>> selector, CancellationToken cancellationToken = default) - where TResult : notnull - => source.MinOrNoneAsync(selector, cancellationToken); } } #endif diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/None.cs b/Funcky/Extensions/AsyncEnumerableExtensions/None.cs index d22b1f672..438be0b66 100644 --- a/Funcky/Extensions/AsyncEnumerableExtensions/None.cs +++ b/Funcky/Extensions/AsyncEnumerableExtensions/None.cs @@ -21,18 +21,6 @@ public async ValueTask NoneAsync(Func predicate, Cancellati [Pure] public async ValueTask NoneAsync(Func> predicate, CancellationToken cancellationToken = default) => !await source.AnyAsync(predicate, cancellationToken).ConfigureAwait(false); - - /// - [Pure] - [Obsolete("Use NoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask NoneAwaitAsync(Func> predicate, CancellationToken cancellationToken = default) - => source.NoneAsync((item, _) => predicate(item), cancellationToken); - - /// - [Pure] - [Obsolete("Use NoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask NoneAwaitWithCancellationAsync(Func> predicate, CancellationToken cancellationToken = default) - => source.NoneAsync(predicate, cancellationToken); } } #endif diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/Partition.cs b/Funcky/Extensions/AsyncEnumerableExtensions/Partition.cs index fc87f9282..8aa6164f4 100644 --- a/Funcky/Extensions/AsyncEnumerableExtensions/Partition.cs +++ b/Funcky/Extensions/AsyncEnumerableExtensions/Partition.cs @@ -35,22 +35,6 @@ public static ValueTask> PartitionAsync( CancellationToken cancellationToken = default) => source.PartitionAsync(predicate, static (left, right, _) => ValueTaskFromResult(Partitions.Create(left, right)), cancellationToken); - /// - [Obsolete("Use PartitionAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public static ValueTask> PartitionAwaitAsync( - this IAsyncEnumerable source, - Func> predicate, - CancellationToken cancellationToken = default) - => source.PartitionAsync((item, _) => predicate(item), cancellationToken); - - /// - [Obsolete("Use PartitionAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public static ValueTask> PartitionAwaitWithCancellationAsync( - this IAsyncEnumerable source, - Func> predicate, - CancellationToken cancellationToken = default) - => source.PartitionAsync(predicate, cancellationToken); - /// /// Partitions the items in an by the given . /// The receives the items for which the predicate holds and the items @@ -86,24 +70,6 @@ public static async ValueTask PartitionAsync( return await resultSelector(left, right, cancellationToken).ConfigureAwait(false); } - /// - [Obsolete("Use PartitionAsync with (…, cancellationToken) delegates instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public static ValueTask PartitionAwaitAsync( - this IAsyncEnumerable source, - Func> predicate, - Func, IReadOnlyList, ValueTask> resultSelector, - CancellationToken cancellationToken = default) - => source.PartitionAsync((item, _) => predicate(item), (left, right, _) => resultSelector(left, right), cancellationToken); - - /// - [Obsolete("Use PartitionAsync instead, which takes the same delegates. This method will be removed in Funcky 4.0.0.")] - public static ValueTask PartitionAwaitWithCancellationAsync( - this IAsyncEnumerable source, - Func> predicate, - Func, IReadOnlyList, CancellationToken, ValueTask> resultSelector, - CancellationToken cancellationToken = default) - => source.PartitionAsync(predicate, resultSelector, cancellationToken); - private static Func, TSource, CancellationToken, ValueTask>> AddAsync( Func> predicate) => async (builder, element, cancellationToken) => await predicate(element, cancellationToken).ConfigureAwait(false) ? builder.AddLeft(element) : builder.AddRight(element); diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/Scan.cs b/Funcky/Extensions/AsyncEnumerableExtensions/Scan.cs index e3491147c..3c59f9fe2 100644 --- a/Funcky/Extensions/AsyncEnumerableExtensions/Scan.cs +++ b/Funcky/Extensions/AsyncEnumerableExtensions/Scan.cs @@ -31,28 +31,6 @@ public IAsyncEnumerable InclusiveScan(TAccumulate seed public IAsyncEnumerable InclusiveScan(TAccumulate seed, Func> accumulator) => InclusiveScanAwaitWithCancellationEnumerable(ArgumentValidator.NotNull(source), seed, ArgumentValidator.NotNull(accumulator)); - /// - /// Scan generates a sequence known as the inclusive prefix sum. - /// - /// The seed and target type. - /// The seed or neutral element (identity). - /// An awaitable binary operator to aggregate a value. - /// A sequence of aggregated values. - [Obsolete("Use InclusiveScan with a (accumulate, item, cancellationToken) delegate instead; discard the token with (accumulate, item, _) => …. This method will be removed in Funcky 4.0.0.")] - public IAsyncEnumerable InclusiveScanAwait(TAccumulate seed, Func> accumulator) - => InclusiveScanAwaitEnumerable(ArgumentValidator.NotNull(source), seed, ArgumentValidator.NotNull(accumulator)); - - /// - /// Scan generates a sequence known as the inclusive prefix sum. - /// - /// The seed and target type. - /// The seed or neutral element (identity). - /// A binary operator to aggregate a value. - /// A sequence of aggregated values. - [Obsolete("Use InclusiveScan instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public IAsyncEnumerable InclusiveScanAwaitWithCancellation(TAccumulate seed, Func> accumulator) - => InclusiveScanAwaitWithCancellationEnumerable(ArgumentValidator.NotNull(source), seed, ArgumentValidator.NotNull(accumulator)); - /// /// Scan generates a sequence known as the exclusive prefix sum. /// @@ -74,28 +52,6 @@ public IAsyncEnumerable ExclusiveScan(TAccumulate seed public IAsyncEnumerable ExclusiveScan(TAccumulate seed, Func> accumulator) => ExclusiveScanAwaitWithCancellationEnumerable(ArgumentValidator.NotNull(source), seed, ArgumentValidator.NotNull(accumulator)); - /// - /// Scan generates a sequence known as the exclusive prefix sum. - /// - /// The seed and target type. - /// The seed or neutral element (identity). - /// An awaitable binary operator to aggregate a value. - /// A sequence of aggregated values. - [Obsolete("Use ExclusiveScan with a (accumulate, item, cancellationToken) delegate instead; discard the token with (accumulate, item, _) => …. This method will be removed in Funcky 4.0.0.")] - public IAsyncEnumerable ExclusiveScanAwait(TAccumulate seed, Func> accumulator) - => ExclusiveScanAwaitEnumerable(ArgumentValidator.NotNull(source), seed, ArgumentValidator.NotNull(accumulator)); - - /// - /// Scan generates a sequence known as the exclusive prefix sum. - /// - /// The seed and target type. - /// The seed or neutral element (identity). - /// An awaitable binary operator to aggregate a value. - /// A sequence of aggregated values. - [Obsolete("Use ExclusiveScan instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public IAsyncEnumerable ExclusiveScanAwaitWithCancellation(TAccumulate seed, Func> accumulator) - => ExclusiveScanAwaitWithCancellationEnumerable(ArgumentValidator.NotNull(source), seed, ArgumentValidator.NotNull(accumulator)); - private async IAsyncEnumerable InclusiveScanAwaitWithCancellationEnumerable(TAccumulate seed, Func> accumulator, [EnumeratorCancellation] CancellationToken cancellationToken = default) { var enumerator = source.GetAsyncEnumerator(cancellationToken); @@ -120,18 +76,6 @@ private async IAsyncEnumerable ExclusiveScanEnumerable } } - private async IAsyncEnumerable ExclusiveScanAwaitEnumerable(TAccumulate seed, Func> accumulator, [EnumeratorCancellation] CancellationToken cancellationToken = default) - { - var enumerator = source.GetAsyncEnumerator(cancellationToken); - await using var enumeratorGuard = enumerator.ConfigureAwait(false); - - while (await enumerator.MoveNextAsync().ConfigureAwait(false)) - { - yield return seed; - seed = await accumulator(seed, enumerator.Current).ConfigureAwait(false); - } - } - private async IAsyncEnumerable ExclusiveScanAwaitWithCancellationEnumerable(TAccumulate seed, Func> accumulator, [EnumeratorCancellation] CancellationToken cancellationToken = default) { var enumerator = source.GetAsyncEnumerator(cancellationToken); @@ -156,17 +100,5 @@ private static async IAsyncEnumerable InclusiveScanEnumerable InclusiveScanAwaitEnumerable(IAsyncEnumerable source, TAccumulate seed, Func> accumulator, [EnumeratorCancellation] CancellationToken cancellationToken = default) - { - var enumerator = source.GetAsyncEnumerator(cancellationToken); - await using var enumeratorGuard = enumerator.ConfigureAwait(false); - - while (await enumerator.MoveNextAsync().ConfigureAwait(false)) - { - seed = await accumulator(seed, enumerator.Current).ConfigureAwait(false); - yield return seed; - } - } } #endif diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/SingleOrNone.cs b/Funcky/Extensions/AsyncEnumerableExtensions/SingleOrNone.cs index 1b4e1d3d8..1040397c9 100644 --- a/Funcky/Extensions/AsyncEnumerableExtensions/SingleOrNone.cs +++ b/Funcky/Extensions/AsyncEnumerableExtensions/SingleOrNone.cs @@ -31,18 +31,6 @@ public async ValueTask> SingleOrNoneAsync(Func pr [Pure] public async ValueTask> SingleOrNoneAsync(Func> predicate, CancellationToken cancellationToken = default) => await source.Where(predicate).Select(Option.Some).SingleOrDefaultAsync(cancellationToken).ConfigureAwait(false); - - /// - [Pure] - [Obsolete("Use SingleOrNoneAsync with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public ValueTask> SingleOrNoneAwaitAsync(Func> predicate, CancellationToken cancellationToken = default) - => source.SingleOrNoneAsync((item, _) => predicate(item), cancellationToken); - - /// - [Pure] - [Obsolete("Use SingleOrNoneAsync instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public ValueTask> SingleOrNoneAwaitWithCancellationAsync(Func> predicate, CancellationToken cancellationToken = default) - => source.SingleOrNoneAsync(predicate, cancellationToken); } } #endif diff --git a/Funcky/Extensions/AsyncEnumerableExtensions/WhereSelect.cs b/Funcky/Extensions/AsyncEnumerableExtensions/WhereSelect.cs index 677111b6e..a248a58a3 100644 --- a/Funcky/Extensions/AsyncEnumerableExtensions/WhereSelect.cs +++ b/Funcky/Extensions/AsyncEnumerableExtensions/WhereSelect.cs @@ -60,34 +60,6 @@ public IAsyncEnumerable WhereSelect(Func WhereSelect(Func>> selector) where TResult : notnull => WhereSelectAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(selector)); - - /// - [Pure] - [Obsolete("Use WhereSelect with a (item, cancellationToken) delegate instead; discard the token with (item, _) => …. This method will be removed in Funcky 4.0.0.")] - public IAsyncEnumerable WhereSelectAwait(Func>> selector) - where TResult : notnull - => WhereSelectAwaitInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(selector)); - - /// - [Pure] - [Obsolete("Use WhereSelect with a (item, index, cancellationToken) delegate instead; discard the token with (item, index, _) => …. This method will be removed in Funcky 4.0.0.")] - public IAsyncEnumerable WhereSelectAwait(Func>> selector) - where TResult : notnull - => WhereSelectAwaitInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(selector)); - - /// - [Pure] - [Obsolete("Use WhereSelect instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public IAsyncEnumerable WhereSelectAwaitWithCancellation(Func>> selector) - where TResult : notnull - => WhereSelectAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(selector)); - - /// - [Pure] - [Obsolete("Use WhereSelect instead, which takes the same delegate. This method will be removed in Funcky 4.0.0.")] - public IAsyncEnumerable WhereSelectAwaitWithCancellation(Func>> selector) - where TResult : notnull - => WhereSelectAwaitWithCancellationInternal(ArgumentValidator.NotNull(source), ArgumentValidator.NotNull(selector)); } private static async IAsyncEnumerable WhereSelectInternal(IAsyncEnumerable source, Func> selector, [EnumeratorCancellation] CancellationToken cancellationToken = default) @@ -121,37 +93,6 @@ private static async IAsyncEnumerable WhereSelectInternal WhereSelectAwaitInternal(IAsyncEnumerable source, Func>> selector, [EnumeratorCancellation] CancellationToken cancellationToken = default) - where TResult : notnull - { - await foreach (var item in source.WithCancellation(cancellationToken).ConfigureAwait(false)) - { - if ((await selector(item).ConfigureAwait(false)).TryGetValue(out var result)) - { - yield return result; - } - } - } - - private static async IAsyncEnumerable WhereSelectAwaitInternal(IAsyncEnumerable source, Func>> selector, [EnumeratorCancellation] CancellationToken cancellationToken = default) - where TResult : notnull - { - var index = 0; - - await foreach (var item in source.WithCancellation(cancellationToken).ConfigureAwait(false)) - { - if ((await selector(item, index).ConfigureAwait(false)).TryGetValue(out var result)) - { - yield return result; - } - - checked - { - index++; - } - } - } - private static async IAsyncEnumerable WhereSelectAwaitWithCancellationInternal(IAsyncEnumerable source, Func>> selector, [EnumeratorCancellation] CancellationToken cancellationToken = default) where TResult : notnull { diff --git a/Funcky/PublicAPI/net10.0/PublicAPI.Unshipped.txt b/Funcky/PublicAPI/net10.0/PublicAPI.Unshipped.txt index e72aadc33..66c503ce4 100644 --- a/Funcky/PublicAPI/net10.0/PublicAPI.Unshipped.txt +++ b/Funcky/PublicAPI/net10.0/PublicAPI.Unshipped.txt @@ -2,3 +2,119 @@ *REMOVED*static Funcky.Monads.Option.FromBoolean(bool boolean) -> Funcky.Monads.Option *REMOVED*static Funcky.Monads.Option.FromBoolean(bool boolean, System.Func! selector) -> Funcky.Monads.Option *REMOVED*static Funcky.Monads.Option.FromBoolean(bool boolean, TItem item) -> Funcky.Monads.Option +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Func!, System.Collections.Generic.IReadOnlyList!, System.Threading.Tasks.ValueTask>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Func!, System.Collections.Generic.IReadOnlyList!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ChunkAwait(int size, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ChunkAwaitWithCancellation(int size, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ExclusiveScanAwait(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ExclusiveScanAwaitWithCancellation(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).FirstOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).FirstOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InclusiveScanAwait(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InclusiveScanAwaitWithCancellation(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InspectAwait(System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InspectAwaitWithCancellation(System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).LastOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).LastOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).NoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).NoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).SingleOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).SingleOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwait(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwait(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwaitWithCancellation(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwaitWithCancellation(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ChunkAwait(this System.Collections.Generic.IAsyncEnumerable! source, int size, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ChunkAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, int size, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ExclusiveScanAwait(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ExclusiveScanAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.FirstOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.FirstOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InclusiveScanAwait(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InclusiveScanAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InspectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InspectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.LastOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.LastOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.NoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.NoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.SingleOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.SingleOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! diff --git a/Funcky/PublicAPI/net11.0/PublicAPI.Unshipped.txt b/Funcky/PublicAPI/net11.0/PublicAPI.Unshipped.txt index ba81baeda..e9fc8675c 100644 --- a/Funcky/PublicAPI/net11.0/PublicAPI.Unshipped.txt +++ b/Funcky/PublicAPI/net11.0/PublicAPI.Unshipped.txt @@ -48,3 +48,119 @@ static Funcky.Extensions.StringExtensions.LastIndexOfOrNone(this string! haystac *REMOVED*static Funcky.Monads.Option.FromBoolean(bool boolean) -> Funcky.Monads.Option *REMOVED*static Funcky.Monads.Option.FromBoolean(bool boolean, System.Func! selector) -> Funcky.Monads.Option *REMOVED*static Funcky.Monads.Option.FromBoolean(bool boolean, TItem item) -> Funcky.Monads.Option +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func>! elementSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AdjacentGroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! keySelector, System.Collections.Generic.IEqualityComparer! comparer) -> System.Collections.Generic.IAsyncEnumerable!>! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Func!, System.Collections.Generic.IReadOnlyList!, System.Threading.Tasks.ValueTask>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Func!, System.Collections.Generic.IReadOnlyList!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.PartitionAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).AverageOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ChunkAwait(int size, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ChunkAwaitWithCancellation(int size, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ExclusiveScanAwait(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).ExclusiveScanAwaitWithCancellation(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).FirstOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).FirstOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InclusiveScanAwait(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InclusiveScanAwaitWithCancellation(TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InspectAwait(System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).InspectAwaitWithCancellation(System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).LastOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).LastOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MaxOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitWithCancellationAsync(System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).MinOrNoneAwaitWithCancellationAsync(System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).NoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).NoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).SingleOrNoneAwaitAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).SingleOrNoneAwaitWithCancellationAsync(System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwait(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwait(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwaitWithCancellation(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*Funcky.Extensions.AsyncEnumerableExtensions.extension(System.Collections.Generic.IAsyncEnumerable!).WhereSelectAwaitWithCancellation(System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.AverageOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ChunkAwait(this System.Collections.Generic.IAsyncEnumerable! source, int size, System.Func!, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ChunkAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, int size, System.Func!, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>! resultSelector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ExclusiveScanAwait(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.ExclusiveScanAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.FirstOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.FirstOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InclusiveScanAwait(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InclusiveScanAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, TAccumulate seed, System.Func>! accumulator) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InspectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.InspectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func! inspector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.LastOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.LastOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MaxOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.MinOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! selector, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.NoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.NoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.SingleOrNoneAwaitAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.SingleOrNoneAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>! predicate, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask> +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwait(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! +*REMOVED*static Funcky.Extensions.AsyncEnumerableExtensions.WhereSelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable! source, System.Func>>! selector) -> System.Collections.Generic.IAsyncEnumerable! diff --git a/changelog.md b/changelog.md index aff1791f1..60aaea9f1 100644 --- a/changelog.md +++ b/changelog.md @@ -16,6 +16,23 @@ Funcky adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). value. The code fix in Funcky.Analyzers 3.0.0 now also fires on the compile error CS0117 that the removed member leaves behind, so a project can upgrade to Funcky 4.0.0 first and let the fix (or Fix-All) rewrite every call afterwards; the fix for the obsoletion warning CS0618 on Funcky 3.8.0 stays as well. +* Breaking (Funcky.Async 2.0.0): the package no longer depends on System.Linq.Async but on System.Linq.AsyncEnumerable + (`[10.0.6, 12)`), the package that is the `IAsyncEnumerable` LINQ of the .NET 10 base class library, so the operators + have the same shapes on every framework. The members that only existed to bridge System.Linq.Async 5 and 6 are gone: + `Chunk(size)` without a result selector (System.Linq.AsyncEnumerable provides it, yielding `T[]`), and + `AdjacentGroupBy` now returns `IAsyncEnumerable>` instead of `IAsyncGrouping` on every framework, + exactly like the net10.0 asset of Funcky. A project that still references System.Linq.Async 5 or 6 next to + Funcky.Async 2.0.0 gets a type clash (CS0433) on `System.Linq.AsyncEnumerable`: upgrade that reference to + System.Linq.Async 7, which forwards to the same package, or drop it. Funcky.Async 1.x stays available for projects + that cannot. System.Linq.Async 7 itself was not chosen as the dependency because it also brings System.Interactive.Async + along, whose `Merge` on a sequence of sequences would silently take over from Funcky's sorted `Merge`. +* Breaking: the twelve `…Await` and `…AwaitWithCancellation` operators (`AdjacentGroupBy`, `Chunk`, `ExclusiveScan`, + `InclusiveScan`, `Inspect`, `WhereSelect`) and the `…AwaitAsync` and `…AwaitWithCancellationAsync` overloads of the + eight terminal aggregations (`AverageOrNone`, `FirstOrNone`, `LastOrNone`, `SingleOrNone`, `MaxOrNone`, `MinOrNone`, + `None`, `Partition`), obsolete since 3.8.0, are removed from the net10.0 asset of Funcky and from Funcky.Async. Use the + single-name overloads with a `(…, cancellationToken)` delegate. The code fix in Funcky.Analyzers 3.0.0 now also fires + on the compile error CS1061 that a removed name leaves behind, so a project can upgrade first and let Fix-All rewrite + every call afterwards; the fix for the obsoletion warning CS0618 on 3.8.0 stays as well. * Funcky and Funcky.Async add a `net11.0` asset and are built with the .NET 11 SDK (release candidate 3 while .NET 11 is in preview). The `net11.0` asset of Funcky.Async only forwards to Funcky, like the `net10.0` one. No target framework is removed in this step; see `SupportPolicy.md` for the frameworks Funcky 4 drops.