The Big Rename to avoid ambiguity between sync/async/cancellable overloads of operators.

Ix.NET/Source/System.Linq.Async.Queryable/System.Linq.Async.Queryable.csproj

@@ -23,4 +23,8 @@
     </None>
   </ItemGroup>
 
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
 </Project>

Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncQueryable.Generated.tt

@@ -15,7 +15,7 @@
 <#@ output extension=".cs" #>
 <#
 var nullableParameterNames = new[] { "comparer" };
-var exclude = new[] { "ForEach", "ForEachAsync", "ToEnumerable", "ToAsyncEnumerable", "ToObservable", "AsAsyncEnumerable", "WithCancellation" };
+var exclude = new[] { "ForEachAsync", "ForEachAwaitAsync", "ForEachAwaitWithCancellationAsync", "ToEnumerable", "ToAsyncEnumerable", "ToObservable", "AsAsyncEnumerable", "WithCancellation" };
 
 var toQuotedImpl = default(Func<Type, int, bool, string>);
 toQuotedImpl = (t, i, b) =>

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/AsyncEnumerableNamingTests.cs

@@ -0,0 +1,84 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information. 
+
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Tests
+{
+    public class AsyncEnumerableNamingTests
+    {
+        [Fact]
+        public static void AsyncEnumerable_MethodNames()
+        {
+            var methods = typeof(AsyncEnumerable).GetMethods(BindingFlags.Public | BindingFlags.Static);
+
+            //
+            // Async suffix
+            //
+
+            var asyncMethodsNoAsyncSuffix = (from m in methods
+                                             where IsTaskLike(m.ReturnType)
+                                             where !m.Name.EndsWith("Async")
+                                             select m.Name)
+                                            .ToArray();
+
+            Assert.Empty(asyncMethodsNoAsyncSuffix);
+
+            //
+            // Consistency of delegate types and Await[WithCancellation] naming convention
+            //
+
+            var methodsWithDelegateParameter = (from m in methods
+                                                where m.GetParameters().Any(p => IsAsyncDelegate(p.ParameterType))
+                                                select m)
+                                               .ToArray();
+
+            foreach (var m in methodsWithDelegateParameter)
+            {
+                var kinds = (from p in m.GetParameters()
+                             where IsDelegate(p.ParameterType)
+                             select GetDelegateKind(p.ParameterType))
+                            .Distinct();
+
+                Assert.Single(kinds);
+
+                var suffix = IsTaskLike(m.ReturnType) ? "Async" : "";
+
+                switch (kinds.Single())
+                {
+                    case DelegateKind.Async:
+                        suffix = "Await" + suffix;
+                        break;
+                    case DelegateKind.AsyncCancel:
+                        suffix = "AwaitWithCancellation" + suffix;
+                        break;
+                }
+
+                Assert.EndsWith(suffix, m.Name);
+            }
+
+            static bool IsValueTask(Type t) => t == typeof(ValueTask) || (t.IsConstructedGenericType && t.GetGenericTypeDefinition() == typeof(ValueTask<>));
+            static bool IsTask(Type t) => typeof(Task).IsAssignableFrom(t);
+            static bool IsTaskLike(Type t) => IsTask(t) || IsValueTask(t);
+
+            static bool IsDelegate(Type t) => typeof(Delegate).IsAssignableFrom(t);
+            static bool TryGetInvoke(Type t, out MethodInfo m) => (m = t.GetMethod("Invoke")) != null;
+            static bool IsAsyncDelegate(Type t) => IsDelegate(t) && TryGetInvoke(t, out var i) && IsTaskLike(i.ReturnType);
+            static bool IsCancelableDelegate(Type t) => IsDelegate(t) && TryGetInvoke(t, out var i) && i.GetParameters().LastOrDefault()?.ParameterType == typeof(CancellationToken);
+            static DelegateKind GetDelegateKind(Type t) => IsAsyncDelegate(t) ? (IsCancelableDelegate(t) ? DelegateKind.AsyncCancel : DelegateKind.Async) : DelegateKind.Sync;
+        }
+
+        private enum DelegateKind
+        {
+            Sync,
+            Async,
+            AsyncCancel,
+        }
+    }
+}

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Aggregate.cs

@@ -13,23 +13,23 @@ namespace Tests
     public class Aggregate : AsyncEnumerableTests
     {
         [Fact]
-        public async Task AggregateAsync_Sync_Null()
+        public async Task AggregateAsync_Null()
         {
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int>(default, (x, y) => x + y).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, default(Func<int, int, int>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, default).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int>(default, 0, (x, y) => x + y).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default(Func<int, int, int>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int, int>(default, 0, (x, y) => x + y, z => z).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default, z => z).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int, int>(Return42, 0, (x, y) => x + y, default).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int>(default, (x, y) => x + y, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, default(Func<int, int, int>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, default, CancellationToken.None).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int>(default, 0, (x, y) => x + y, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default(Func<int, int, int>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default, CancellationToken.None).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int, int>(default, 0, (x, y) => x + y, z => z, CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default, z => z, CancellationToken.None).AsTask());
@@ -37,7 +37,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Sync_Simple()
+        public async Task AggregateAsync_Simple()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.AggregateAsync((x, y) => x * y);
@@ -45,7 +45,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Sync_Empty()
+        public async Task AggregateAsync_Empty()
         {
             var xs = new int[0].ToAsyncEnumerable();
             var ys = xs.AggregateAsync((x, y) => x * y);
@@ -53,7 +53,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Sync_Throw_Source()
+        public async Task AggregateAsync_Throw_Source()
         {
             var ex = new Exception("Bang!");
             var xs = Throw<int>(ex);
@@ -62,7 +62,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Sync_Throw_Selector()
+        public async Task AggregateAsync_Throw_Selector()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -71,7 +71,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Sync_Seed_Simple()
+        public async Task AggregateAsync_Seed_Simple()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.AggregateAsync(1, (x, y) => x * y);
@@ -79,7 +79,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Sync_Seed_Emtpy()
+        public async Task AggregateAsync_Seed_Emtpy()
         {
             var xs = new int[0].ToAsyncEnumerable();
             var ys = xs.AggregateAsync(1, (x, y) => x * y);
@@ -87,7 +87,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Sync_Seed_Throw_Source()
+        public async Task AggregateAsync_Seed_Throw_Source()
         {
             var ex = new Exception("Bang!");
             var xs = Throw<int>(ex);
@@ -96,7 +96,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Sync_Seed_Throw_Selector()
+        public async Task AggregateAsync_Seed_Throw_Selector()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -105,7 +105,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Sync_Seed_Result_Simple()
+        public async Task AggregateAsync_Seed_Result_Simple()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.AggregateAsync(1, (x, y) => x * y, x => x + 1);
@@ -113,7 +113,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Sync_Seed_Result_Empty()
+        public async Task AggregateAsync_Seed_Result_Empty()
         {
             var xs = new int[0].ToAsyncEnumerable();
             var ys = xs.AggregateAsync(1, (x, y) => x * y, x => x + 1);
@@ -121,7 +121,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Sync_Seed_Result_Throw_Source()
+        public async Task AggregateAsync_Seed_Result_Throw_Source()
         {
             var ex = new Exception("Bang!");
             var xs = Throw<int>(ex);
@@ -130,7 +130,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Sync_Seed_Result_Throw_Selector()
+        public async Task AggregateAsync_Seed_Result_Throw_Selector()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -139,7 +139,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Sync_Seed_Result_Throw_ResultSelector()
+        public async Task AggregateAsync_Seed_Result_Throw_ResultSelector()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -148,273 +148,273 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Null()
+        public async Task AggregateAwaitAsync_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int>(default, (x, y) => new ValueTask<int>(x + y)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, default(Func<int, int, ValueTask<int>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync<int>(default, (x, y) => new ValueTask<int>(x + y)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int>(default, 0, (x, y) => new ValueTask<int>(x + y)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default(Func<int, int, ValueTask<int>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync<int, int>(default, 0, (x, y) => new ValueTask<int>(x + y)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync(Return42, 0, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int, int>(default, 0, (x, y) => new ValueTask<int>(x + y), z => new ValueTask<int>(z)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default(Func<int, int, ValueTask<int>>), z => new ValueTask<int>(z)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int, int>(Return42, 0, (x, y) => new ValueTask<int>(x + y), default).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync<int, int, int>(default, 0, (x, y) => new ValueTask<int>(x + y), z => new ValueTask<int>(z)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync(Return42, 0, default, z => new ValueTask<int>(z)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync<int, int, int>(Return42, 0, (x, y) => new ValueTask<int>(x + y), default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int>(default, (x, y) => new ValueTask<int>(x + y), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, default(Func<int, int, ValueTask<int>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync<int>(default, (x, y) => new ValueTask<int>(x + y), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync(Return42, default, CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int>(default, 0, (x, y) => new ValueTask<int>(x + y), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default(Func<int, int, ValueTask<int>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync<int, int>(default, 0, (x, y) => new ValueTask<int>(x + y), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync(Return42, 0, default, CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int, int>(default, 0, (x, y) => new ValueTask<int>(x + y), z => new ValueTask<int>(z), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default(Func<int, int, ValueTask<int>>), z => new ValueTask<int>(z), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int, int>(Return42, 0, (x, y) => new ValueTask<int>(x + y), default, CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync<int, int, int>(default, 0, (x, y) => new ValueTask<int>(x + y), z => new ValueTask<int>(z), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync(Return42, 0, default, z => new ValueTask<int>(z), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitAsync<int, int, int>(Return42, 0, (x, y) => new ValueTask<int>(x + y), default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Simple()
+        public async Task AggregateAwaitAsync_Simple()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync((x, y) => new ValueTask<int>(x * y));
+            var ys = xs.AggregateAwaitAsync((x, y) => new ValueTask<int>(x * y));
             Assert.Equal(24, await ys);
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Empty()
+        public async Task AggregateAwaitAsync_Empty()
         {
             var xs = new int[0].ToAsyncEnumerable();
-            var ys = xs.AggregateAsync((x, y) => new ValueTask<int>(x * y));
+            var ys = xs.AggregateAwaitAsync((x, y) => new ValueTask<int>(x * y));
             await AssertThrowsAsync<InvalidOperationException>(ys.AsTask());
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Throw_Source()
+        public async Task AggregateAwaitAsync_Throw_Source()
         {
             var ex = new Exception("Bang!");
             var xs = Throw<int>(ex);
-            var ys = xs.AggregateAsync((x, y) => new ValueTask<int>(x * y));
+            var ys = xs.AggregateAwaitAsync((x, y) => new ValueTask<int>(x * y));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Throw_Selector()
+        public async Task AggregateAwaitAsync_Throw_Selector()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(new Func<int, int, ValueTask<int>>((x, y) => { throw ex; }));
+            var ys = xs.AggregateAwaitAsync(new Func<int, int, ValueTask<int>>((x, y) => { throw ex; }));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Seed_Simple()
+        public async Task AggregateAwaitAsync_Seed_Simple()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(1, (x, y) => new ValueTask<int>(x * y));
+            var ys = xs.AggregateAwaitAsync(1, (x, y) => new ValueTask<int>(x * y));
             Assert.Equal(24, await ys);
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Seed_Emtpy()
+        public async Task AggregateAwaitAsync_Seed_Emtpy()
         {
             var xs = new int[0].ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(1, (x, y) => new ValueTask<int>(x * y));
+            var ys = xs.AggregateAwaitAsync(1, (x, y) => new ValueTask<int>(x * y));
             Assert.Equal(1, await ys);
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Seed_Throw_Source()
+        public async Task AggregateAwaitAsync_Seed_Throw_Source()
         {
             var ex = new Exception("Bang!");
             var xs = Throw<int>(ex);
-            var ys = xs.AggregateAsync(1, (x, y) => new ValueTask<int>(x * y));
+            var ys = xs.AggregateAwaitAsync(1, (x, y) => new ValueTask<int>(x * y));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Seed_Throw_Selector()
+        public async Task AggregateAwaitAsync_Seed_Throw_Selector()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(1, new Func<int, int, ValueTask<int>>((x, y) => { throw ex; }));
+            var ys = xs.AggregateAwaitAsync(1, new Func<int, int, ValueTask<int>>((x, y) => { throw ex; }));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Seed_Result_Simple()
+        public async Task AggregateAwaitAsync_Seed_Result_Simple()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(1, (x, y) => new ValueTask<int>(x * y), x => new ValueTask<int>(x + 1));
+            var ys = xs.AggregateAwaitAsync(1, (x, y) => new ValueTask<int>(x * y), x => new ValueTask<int>(x + 1));
             Assert.Equal(25, await ys);
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Seed_Result_Empty()
+        public async Task AggregateAwaitAsync_Seed_Result_Empty()
         {
             var xs = new int[0].ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(1, (x, y) => new ValueTask<int>(x * y), x => new ValueTask<int>(x + 1));
+            var ys = xs.AggregateAwaitAsync(1, (x, y) => new ValueTask<int>(x * y), x => new ValueTask<int>(x + 1));
             Assert.Equal(2, await ys);
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Seed_Result_Throw_Source()
+        public async Task AggregateAwaitAsync_Seed_Result_Throw_Source()
         {
             var ex = new Exception("Bang!");
             var xs = Throw<int>(ex);
-            var ys = xs.AggregateAsync(1, (x, y) => new ValueTask<int>(x * y), x => new ValueTask<int>(x + 1));
+            var ys = xs.AggregateAwaitAsync(1, (x, y) => new ValueTask<int>(x * y), x => new ValueTask<int>(x + 1));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Seed_Result_Throw_Selector()
+        public async Task AggregateAwaitAsync_Seed_Result_Throw_Selector()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(1, new Func<int, int, ValueTask<int>>((x, y) => { throw ex; }), x => new ValueTask<int>(x + 1));
+            var ys = xs.AggregateAwaitAsync(1, new Func<int, int, ValueTask<int>>((x, y) => { throw ex; }), x => new ValueTask<int>(x + 1));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task AggregateAsync_Async_Seed_Result_Throw_ResultSelector()
+        public async Task AggregateAwaitAsync_Seed_Result_Throw_ResultSelector()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync<int, int, int>(1, (x, y) => new ValueTask<int>(x * y), x => { throw ex; });
+            var ys = xs.AggregateAwaitAsync<int, int, int>(1, (x, y) => new ValueTask<int>(x * y), x => { throw ex; });
             await AssertThrowsAsync(ys, ex);
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Null()
+        public async Task AggregateAwaitWithCancellationAsync_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int>(default, (x, y, ct) => new ValueTask<int>(x + y)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, default(Func<int, int, CancellationToken, ValueTask<int>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync<int>(default, (x, y, ct) => new ValueTask<int>(x + y)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int>(default, 0, (x, y, ct) => new ValueTask<int>(x + y)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default(Func<int, int, CancellationToken, ValueTask<int>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync<int, int>(default, 0, (x, y, ct) => new ValueTask<int>(x + y)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync(Return42, 0, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int, int>(default, 0, (x, y, ct) => new ValueTask<int>(x + y), (z, ct) => new ValueTask<int>(z)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default, (z, ct) => new ValueTask<int>(z)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int, int>(Return42, 0, (x, y, ct) => new ValueTask<int>(x + y), default).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync<int, int, int>(default, 0, (x, y, ct) => new ValueTask<int>(x + y), (z, ct) => new ValueTask<int>(z)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync(Return42, 0, default, (z, ct) => new ValueTask<int>(z)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync<int, int, int>(Return42, 0, (x, y, ct) => new ValueTask<int>(x + y), default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int>(default, (x, y, ct) => new ValueTask<int>(x + y), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, default(Func<int, int, CancellationToken, ValueTask<int>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync<int>(default, (x, y, ct) => new ValueTask<int>(x + y), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync(Return42, default, CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int>(default, 0, (x, y, ct) => new ValueTask<int>(x + y), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default(Func<int, int, CancellationToken, ValueTask<int>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync<int, int>(default, 0, (x, y, ct) => new ValueTask<int>(x + y), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync(Return42, 0, default, CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int, int>(default, 0, (x, y, ct) => new ValueTask<int>(x + y), (z, ct) => new ValueTask<int>(z), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync(Return42, 0, default, (z, ct) => new ValueTask<int>(z), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAsync<int, int, int>(Return42, 0, (x, y, ct) => new ValueTask<int>(x + y), default, CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync<int, int, int>(default, 0, (x, y, ct) => new ValueTask<int>(x + y), (z, ct) => new ValueTask<int>(z), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync(Return42, 0, default, (z, ct) => new ValueTask<int>(z), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AggregateAwaitWithCancellationAsync<int, int, int>(Return42, 0, (x, y, ct) => new ValueTask<int>(x + y), default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Simple()
+        public async Task AggregateAwaitWithCancellationAsync_Simple()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync((x, y, ct) => new ValueTask<int>(x * y));
+            var ys = xs.AggregateAwaitWithCancellationAsync((x, y, ct) => new ValueTask<int>(x * y));
             Assert.Equal(24, await ys);
         }
 
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Empty()
+        public async Task AggregateAwaitWithCancellationAsync_Empty()
         {
             var xs = new int[0].ToAsyncEnumerable();
-            var ys = xs.AggregateAsync((x, y, ct) => new ValueTask<int>(x * y));
+            var ys = xs.AggregateAwaitWithCancellationAsync((x, y, ct) => new ValueTask<int>(x * y));
             await AssertThrowsAsync<InvalidOperationException>(ys.AsTask());
         }
 
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Throw_Source()
+        public async Task AggregateAwaitWithCancellationAsync_Throw_Source()
         {
             var ex = new Exception("Bang!");
             var xs = Throw<int>(ex);
-            var ys = xs.AggregateAsync((x, y, ct) => new ValueTask<int>(x * y));
+            var ys = xs.AggregateAwaitWithCancellationAsync((x, y, ct) => new ValueTask<int>(x * y));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Throw_Selector()
+        public async Task AggregateAwaitWithCancellationAsync_Throw_Selector()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(new Func<int, int, CancellationToken, ValueTask<int>>((x, y, ct) => { throw ex; }));
+            var ys = xs.AggregateAwaitWithCancellationAsync(new Func<int, int, CancellationToken, ValueTask<int>>((x, y, ct) => { throw ex; }));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Seed_Simple()
+        public async Task AggregateAwaitWithCancellationAsync_Seed_Simple()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(1, (x, y, ct) => new ValueTask<int>(x * y));
+            var ys = xs.AggregateAwaitWithCancellationAsync(1, (x, y, ct) => new ValueTask<int>(x * y));
             Assert.Equal(24, await ys);
         }
 
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Seed_Emtpy()
+        public async Task AggregateAwaitWithCancellationAsync_Seed_Emtpy()
         {
             var xs = new int[0].ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(1, (x, y, ct) => new ValueTask<int>(x * y));
+            var ys = xs.AggregateAwaitWithCancellationAsync(1, (x, y, ct) => new ValueTask<int>(x * y));
             Assert.Equal(1, await ys);
         }
 
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Seed_Throw_Source()
+        public async Task AggregateAwaitWithCancellationAsync_Seed_Throw_Source()
         {
             var ex = new Exception("Bang!");
             var xs = Throw<int>(ex);
-            var ys = xs.AggregateAsync(1, (x, y, ct) => new ValueTask<int>(x * y));
+            var ys = xs.AggregateAwaitWithCancellationAsync(1, (x, y, ct) => new ValueTask<int>(x * y));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Seed_Throw_Selector()
+        public async Task AggregateAwaitWithCancellationAsync_Seed_Throw_Selector()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(1, new Func<int, int, CancellationToken, ValueTask<int>>((x, y, ct) => { throw ex; }));
+            var ys = xs.AggregateAwaitWithCancellationAsync(1, new Func<int, int, CancellationToken, ValueTask<int>>((x, y, ct) => { throw ex; }));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Seed_Result_Simple()
+        public async Task AggregateAwaitWithCancellationAsync_Seed_Result_Simple()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(1, (x, y, ct) => new ValueTask<int>(x * y), (x, ct) => new ValueTask<int>(x + 1));
+            var ys = xs.AggregateAwaitWithCancellationAsync(1, (x, y, ct) => new ValueTask<int>(x * y), (x, ct) => new ValueTask<int>(x + 1));
             Assert.Equal(25, await ys);
         }
 
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Seed_Result_Empty()
+        public async Task AggregateAwaitWithCancellationAsync_Seed_Result_Empty()
         {
             var xs = new int[0].ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(1, (x, y, ct) => new ValueTask<int>(x * y), (x, ct) => new ValueTask<int>(x + 1));
+            var ys = xs.AggregateAwaitWithCancellationAsync(1, (x, y, ct) => new ValueTask<int>(x * y), (x, ct) => new ValueTask<int>(x + 1));
             Assert.Equal(2, await ys);
         }
 
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Seed_Result_Throw_Source()
+        public async Task AggregateAwaitWithCancellationAsync_Seed_Result_Throw_Source()
         {
             var ex = new Exception("Bang!");
             var xs = Throw<int>(ex);
-            var ys = xs.AggregateAsync(1, (x, y, ct) => new ValueTask<int>(x * y), (x, ct) => new ValueTask<int>(x + 1));
+            var ys = xs.AggregateAwaitWithCancellationAsync(1, (x, y, ct) => new ValueTask<int>(x * y), (x, ct) => new ValueTask<int>(x + 1));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Seed_Result_Throw_Selector()
+        public async Task AggregateAwaitWithCancellationAsync_Seed_Result_Throw_Selector()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync(1, new Func<int, int, CancellationToken, ValueTask<int>>((x, y, ct) => { throw ex; }), (x, ct) => new ValueTask<int>(x + 1));
+            var ys = xs.AggregateAwaitWithCancellationAsync(1, new Func<int, int, CancellationToken, ValueTask<int>>((x, y, ct) => { throw ex; }), (x, ct) => new ValueTask<int>(x + 1));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task AggregateAsync_AsyncCancel_Seed_Result_Throw_ResultSelector()
+        public async Task AggregateAwaitWithCancellationAsync_Seed_Result_Throw_ResultSelector()
         {
             var ex = new Exception("Bang!");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.AggregateAsync<int, int, int>(1, (x, y, ct) => new ValueTask<int>(x * y), (x, ct) => { throw ex; });
+            var ys = xs.AggregateAwaitWithCancellationAsync<int, int, int>(1, (x, y, ct) => new ValueTask<int>(x * y), (x, ct) => { throw ex; });
             await AssertThrowsAsync(ys, ex);
         }
 #endif

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/All.cs

@@ -13,31 +13,31 @@ namespace Tests
     public class All : AsyncEnumerableTests
     {
         [Fact]
-        public async Task AllAsync_Sync_Null()
+        public async Task AllAsync_Null()
         {
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, x => true).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, bool>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, x => true, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, bool>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task AllAsync_Sync_Simple_False()
+        public async Task AllAsync_Simple_False()
         {
             var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().AllAsync(x => x % 2 == 0);
             Assert.False(await res);
         }
 
         [Fact]
-        public async Task AllAsync_Sync_Simple_True()
+        public async Task AllAsync_Simple_True()
         {
             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAsync(x => x % 2 == 0);
             Assert.True(await res);
         }
 
         [Fact]
-        public async Task AllAsync_Sync_Throw_Source()
+        public async Task AllAsync_Throw_Source()
         {
             var ex = new Exception("Bang!");
             var res = Throw<int>(ex).AllAsync(x => x % 2 == 0);
@@ -45,7 +45,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AllAsync_Sync_Throw_Selector()
+        public async Task AllAsync_Throw_Selector()
         {
             var ex = new Exception("Bang!");
             var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAsync(new Func<int, bool>(x => { throw ex; }));
@@ -53,83 +53,83 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AllAsync_Async_Null()
+        public async Task AllAwaitAsync_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAwaitAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAwaitAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAwaitAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAwaitAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task AllAsync_Async_Simple_False()
+        public async Task AllAwaitAsync_Simple_False()
         {
-            var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().AllAsync(x => new ValueTask<bool>(x % 2 == 0));
+            var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().AllAwaitAsync(x => new ValueTask<bool>(x % 2 == 0));
             Assert.False(await res);
         }
 
         [Fact]
-        public async Task AllAsync_Async_Simple_True()
+        public async Task AllAwaitAsync_Simple_True()
         {
-            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAsync(x => new ValueTask<bool>(x % 2 == 0));
+            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAwaitAsync(x => new ValueTask<bool>(x % 2 == 0));
             Assert.True(await res);
         }
 
         [Fact]
-        public async Task AllAsync_Async_Throw_Source()
+        public async Task AllAwaitAsync_Throw_Source()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).AllAsync(x => new ValueTask<bool>(x % 2 == 0));
+            var res = Throw<int>(ex).AllAwaitAsync(x => new ValueTask<bool>(x % 2 == 0));
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task AllAsync_Async_Throw_Selector()
+        public async Task AllAwaitAsync_Throw_Selector()
         {
             var ex = new Exception("Bang!");
-            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAsync(new Func<int, ValueTask<bool>>(x => { throw ex; }));
+            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAwaitAsync(new Func<int, ValueTask<bool>>(x => { throw ex; }));
             await AssertThrowsAsync(res, ex);
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AllAsync_AsyncCancel_Null()
+        public async Task AllAwaitWithCancellationAsync_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, (x, ct) => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAwaitWithCancellationAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AllAwaitWithCancellationAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task AllAsync_AsyncCancel_Simple_False()
+        public async Task AllAwaitWithCancellationAsync_Simple_False()
         {
-            var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().AllAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
+            var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().AllAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
             Assert.False(await res);
         }
 
         [Fact]
-        public async Task AllAsync_AsyncCancel_Simple_True()
+        public async Task AllAwaitWithCancellationAsync_Simple_True()
         {
-            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
+            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
             Assert.True(await res);
         }
 
         [Fact]
-        public async Task AllAsync_AsyncCancel_Throw_Source()
+        public async Task AllAwaitWithCancellationAsync_Throw_Source()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).AllAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
+            var res = Throw<int>(ex).AllAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task AllAsync_AsyncCancel_Throw_Selector()
+        public async Task AllAwaitWithCancellationAsync_Throw_Selector()
         {
             var ex = new Exception("Bang!");
-            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAsync(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
+            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AllAwaitWithCancellationAsync(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
             await AssertThrowsAsync(res, ex);
         }
 #endif

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Any.cs

@@ -13,7 +13,7 @@ namespace Tests
     public class Any : AsyncEnumerableTests
     {
         [Fact]
-        public async Task AnyAsync_Sync_Null()
+        public async Task AnyAsync_Null()
         {
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync<int>(default).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync<int>(default, CancellationToken.None).AsTask());
@@ -22,7 +22,7 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync(Return42, default(Func<int, bool>)).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync<int>(default, x => true, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync(Return42, default(Func<int, bool>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
@@ -70,83 +70,83 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AnyAsync_Async_Null()
+        public async Task AnyAwaitAsync_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync(Return42, default(Func<int, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAwaitAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAwaitAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync(Return42, default(Func<int, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAwaitAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAwaitAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task AnyAsync_Async_Simple_True()
+        public async Task AnyAwaitAsync_Simple_True()
         {
-            var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().AnyAsync(x => new ValueTask<bool>(x % 2 == 0));
+            var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().AnyAwaitAsync(x => new ValueTask<bool>(x % 2 == 0));
             Assert.True(await res);
         }
 
         [Fact]
-        public async Task AnyAsync_Async_Simple_False()
+        public async Task AnyAwaitAsync_Simple_False()
         {
-            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AnyAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AnyAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.False(await res);
         }
 
         [Fact]
-        public async Task AnyAsync_Async_Throw_Source()
+        public async Task AnyAwaitAsync_Throw_Source()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).AnyAsync(x => new ValueTask<bool>(x % 2 == 0));
+            var res = Throw<int>(ex).AnyAwaitAsync(x => new ValueTask<bool>(x % 2 == 0));
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task AnyAsync_Async_Throw_Selector()
+        public async Task AnyAwaitAsync_Throw_Selector()
         {
             var ex = new Exception("Bang!");
-            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AnyAsync(new Func<int, ValueTask<bool>>(x => { throw ex; }));
+            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AnyAwaitAsync(new Func<int, ValueTask<bool>>(x => { throw ex; }));
             await AssertThrowsAsync(res, ex);
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AnyAsync_AsyncCancel_Null()
+        public async Task AnyAwaitWithCancellationAsync_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync<int>(default, (x, ct) => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAwaitWithCancellationAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AnyAwaitWithCancellationAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task AnyAsync_AsyncCancel_Simple_True()
+        public async Task AnyAwaitWithCancellationAsync_Simple_True()
         {
-            var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().AnyAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
+            var res = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable().AnyAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
             Assert.True(await res);
         }
 
         [Fact]
-        public async Task AnyAsync_AsyncCancel_Simple_False()
+        public async Task AnyAwaitWithCancellationAsync_Simple_False()
         {
-            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AnyAsync((x, ct) => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AnyAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0));
             Assert.False(await res);
         }
 
         [Fact]
-        public async Task AnyAsync_AsyncCancel_Throw_Source()
+        public async Task AnyAwaitWithCancellationAsync_Throw_Source()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).AnyAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
+            var res = Throw<int>(ex).AnyAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task AnyAsync_AsyncCancel_Throw_Selector()
+        public async Task AnyAwaitWithCancellationAsync_Throw_Selector()
         {
             var ex = new Exception("Bang!");
-            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AnyAsync(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
+            var res = new[] { 2, 8, 4 }.ToAsyncEnumerable().AnyAwaitWithCancellationAsync(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
             await AssertThrowsAsync(res, ex);
         }
 #endif

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Average.Generated.cs

@@ -44,34 +44,34 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Int32_Empty()
+        public async Task AverageAwaitAsync_Selector_Int32_Empty()
         {
             var ys = new int[0].ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => new ValueTask<int>(x)).AsTask());
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAwaitAsync(x => new ValueTask<int>(x)).AsTask());
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Int32_Many()
+        public async Task AverageAwaitAsync_Selector_Int32_Many()
         {
             var xs = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<int>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<int>(x)));
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Int32_Empty()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Int32_Empty()
         {
             var ys = new int[0].ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync((x, ct) => new ValueTask<int>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<int>(x), CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Int32_Many()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Int32_Many()
         {
             var xs = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<int>(x), CancellationToken.None));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<int>(x), CancellationToken.None));
         }
 #endif
 
@@ -106,34 +106,34 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Int32_Nullable_Empty()
+        public async Task AverageAwaitAsync_Selector_Int32_Nullable_Empty()
         {
             var ys = new int?[0].ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync(x => new ValueTask<int?>(x)));
+            Assert.Null(await ys.AverageAwaitAsync(x => new ValueTask<int?>(x)));
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Int32_Nullable_Many()
+        public async Task AverageAwaitAsync_Selector_Int32_Nullable_Many()
         {
             var xs = new int?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<int?>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<int?>(x)));
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Int32_Nullable_Empty()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Int32_Nullable_Empty()
         {
             var ys = new int?[0].ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync((x, ct) => new ValueTask<int?>(x), CancellationToken.None));
+            Assert.Null(await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<int?>(x), CancellationToken.None));
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Int32_Nullable_Many()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Int32_Nullable_Many()
         {
             var xs = new int?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<int?>(x), CancellationToken.None));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<int?>(x), CancellationToken.None));
         }
 #endif
 
@@ -168,34 +168,34 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Int64_Empty()
+        public async Task AverageAwaitAsync_Selector_Int64_Empty()
         {
             var ys = new long[0].ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => new ValueTask<long>(x)).AsTask());
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAwaitAsync(x => new ValueTask<long>(x)).AsTask());
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Int64_Many()
+        public async Task AverageAwaitAsync_Selector_Int64_Many()
         {
             var xs = new long[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<long>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<long>(x)));
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Int64_Empty()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Int64_Empty()
         {
             var ys = new long[0].ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync((x, ct) => new ValueTask<long>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<long>(x), CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Int64_Many()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Int64_Many()
         {
             var xs = new long[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<long>(x), CancellationToken.None));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<long>(x), CancellationToken.None));
         }
 #endif
 
@@ -230,34 +230,34 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Int64_Nullable_Empty()
+        public async Task AverageAwaitAsync_Selector_Int64_Nullable_Empty()
         {
             var ys = new long?[0].ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync(x => new ValueTask<long?>(x)));
+            Assert.Null(await ys.AverageAwaitAsync(x => new ValueTask<long?>(x)));
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Int64_Nullable_Many()
+        public async Task AverageAwaitAsync_Selector_Int64_Nullable_Many()
         {
             var xs = new long?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<long?>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<long?>(x)));
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Int64_Nullable_Empty()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Int64_Nullable_Empty()
         {
             var ys = new long?[0].ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync((x, ct) => new ValueTask<long?>(x), CancellationToken.None));
+            Assert.Null(await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<long?>(x), CancellationToken.None));
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Int64_Nullable_Many()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Int64_Nullable_Many()
         {
             var xs = new long?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<long?>(x), CancellationToken.None));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<long?>(x), CancellationToken.None));
         }
 #endif
 
@@ -292,34 +292,34 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Single_Empty()
+        public async Task AverageAwaitAsync_Selector_Single_Empty()
         {
             var ys = new float[0].ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => new ValueTask<float>(x)).AsTask());
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAwaitAsync(x => new ValueTask<float>(x)).AsTask());
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Single_Many()
+        public async Task AverageAwaitAsync_Selector_Single_Many()
         {
             var xs = new float[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<float>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<float>(x)));
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Single_Empty()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Single_Empty()
         {
             var ys = new float[0].ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync((x, ct) => new ValueTask<float>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<float>(x), CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Single_Many()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Single_Many()
         {
             var xs = new float[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<float>(x), CancellationToken.None));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<float>(x), CancellationToken.None));
         }
 #endif
 
@@ -354,34 +354,34 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Single_Nullable_Empty()
+        public async Task AverageAwaitAsync_Selector_Single_Nullable_Empty()
         {
             var ys = new float?[0].ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync(x => new ValueTask<float?>(x)));
+            Assert.Null(await ys.AverageAwaitAsync(x => new ValueTask<float?>(x)));
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Single_Nullable_Many()
+        public async Task AverageAwaitAsync_Selector_Single_Nullable_Many()
         {
             var xs = new float?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<float?>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<float?>(x)));
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Single_Nullable_Empty()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Single_Nullable_Empty()
         {
             var ys = new float?[0].ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync((x, ct) => new ValueTask<float?>(x), CancellationToken.None));
+            Assert.Null(await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<float?>(x), CancellationToken.None));
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Single_Nullable_Many()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Single_Nullable_Many()
         {
             var xs = new float?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<float?>(x), CancellationToken.None));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<float?>(x), CancellationToken.None));
         }
 #endif
 
@@ -416,34 +416,34 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Double_Empty()
+        public async Task AverageAwaitAsync_Selector_Double_Empty()
         {
             var ys = new double[0].ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => new ValueTask<double>(x)).AsTask());
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAwaitAsync(x => new ValueTask<double>(x)).AsTask());
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Double_Many()
+        public async Task AverageAwaitAsync_Selector_Double_Many()
         {
             var xs = new double[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<double>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<double>(x)));
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Double_Empty()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Double_Empty()
         {
             var ys = new double[0].ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync((x, ct) => new ValueTask<double>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<double>(x), CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Double_Many()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Double_Many()
         {
             var xs = new double[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<double>(x), CancellationToken.None));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<double>(x), CancellationToken.None));
         }
 #endif
 
@@ -478,34 +478,34 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Double_Nullable_Empty()
+        public async Task AverageAwaitAsync_Selector_Double_Nullable_Empty()
         {
             var ys = new double?[0].ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync(x => new ValueTask<double?>(x)));
+            Assert.Null(await ys.AverageAwaitAsync(x => new ValueTask<double?>(x)));
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Double_Nullable_Many()
+        public async Task AverageAwaitAsync_Selector_Double_Nullable_Many()
         {
             var xs = new double?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<double?>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<double?>(x)));
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Double_Nullable_Empty()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Double_Nullable_Empty()
         {
             var ys = new double?[0].ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync((x, ct) => new ValueTask<double?>(x), CancellationToken.None));
+            Assert.Null(await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<double?>(x), CancellationToken.None));
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Double_Nullable_Many()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Double_Nullable_Many()
         {
             var xs = new double?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<double?>(x), CancellationToken.None));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<double?>(x), CancellationToken.None));
         }
 #endif
 
@@ -540,34 +540,34 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Decimal_Empty()
+        public async Task AverageAwaitAsync_Selector_Decimal_Empty()
         {
             var ys = new decimal[0].ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => new ValueTask<decimal>(x)).AsTask());
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAwaitAsync(x => new ValueTask<decimal>(x)).AsTask());
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Decimal_Many()
+        public async Task AverageAwaitAsync_Selector_Decimal_Many()
         {
             var xs = new decimal[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<decimal>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<decimal>(x)));
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Decimal_Empty()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Decimal_Empty()
         {
             var ys = new decimal[0].ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync((x, ct) => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Decimal_Many()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Decimal_Many()
         {
             var xs = new decimal[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<decimal>(x), CancellationToken.None));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<decimal>(x), CancellationToken.None));
         }
 #endif
 
@@ -602,34 +602,34 @@ namespace Tests
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Decimal_Nullable_Empty()
+        public async Task AverageAwaitAsync_Selector_Decimal_Nullable_Empty()
         {
             var ys = new decimal?[0].ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync(x => new ValueTask<decimal?>(x)));
+            Assert.Null(await ys.AverageAwaitAsync(x => new ValueTask<decimal?>(x)));
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_Decimal_Nullable_Many()
+        public async Task AverageAwaitAsync_Selector_Decimal_Nullable_Many()
         {
             var xs = new decimal?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<decimal?>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<decimal?>(x)));
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Decimal_Nullable_Empty()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Decimal_Nullable_Empty()
         {
             var ys = new decimal?[0].ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync((x, ct) => new ValueTask<decimal?>(x), CancellationToken.None));
+            Assert.Null(await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<decimal?>(x), CancellationToken.None));
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_Decimal_Nullable_Many()
+        public async Task AverageAwaitWithCancellationAsync_Selector_Decimal_Nullable_Many()
         {
             var xs = new decimal?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<decimal?>(x), CancellationToken.None));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<decimal?>(x), CancellationToken.None));
         }
 #endif
 

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Average.Generated.tt

@@ -74,34 +74,34 @@ foreach (var t in types)
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_<#=t.Name#>_Empty()
+        public async Task AverageAwaitAsync_Selector_<#=t.Name#>_Empty()
         {
             var ys = new <#=cs#>[0].ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync(x => new ValueTask<<#=cs#>>(x)).AsTask());
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAwaitAsync(x => new ValueTask<<#=cs#>>(x)).AsTask());
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_<#=t.Name#>_Many()
+        public async Task AverageAwaitAsync_Selector_<#=t.Name#>_Many()
         {
             var xs = new <#=cs#>[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<<#=cs#>>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<<#=cs#>>(x)));
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_<#=t.Name#>_Empty()
+        public async Task AverageAwaitWithCancellationAsync_Selector_<#=t.Name#>_Empty()
         {
             var ys = new <#=cs#>[0].ToAsyncEnumerable();
-            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAsync((x, ct) => new ValueTask<<#=cs#>>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<InvalidOperationException>(() => ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>>(x), CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_<#=t.Name#>_Many()
+        public async Task AverageAwaitWithCancellationAsync_Selector_<#=t.Name#>_Many()
         {
             var xs = new <#=cs#>[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<<#=cs#>>(x), CancellationToken.None));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>>(x), CancellationToken.None));
         }
 #endif
 
@@ -136,34 +136,34 @@ foreach (var t in types)
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_<#=t.Name#>_Nullable_Empty()
+        public async Task AverageAwaitAsync_Selector_<#=t.Name#>_Nullable_Empty()
         {
             var ys = new <#=cs#>?[0].ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync(x => new ValueTask<<#=cs#>?>(x)));
+            Assert.Null(await ys.AverageAwaitAsync(x => new ValueTask<<#=cs#>?>(x)));
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelector_<#=t.Name#>_Nullable_Many()
+        public async Task AverageAwaitAsync_Selector_<#=t.Name#>_Nullable_Many()
         {
             var xs = new <#=cs#>?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<<#=cs#>?>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<<#=cs#>?>(x)));
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_<#=t.Name#>_Nullable_Empty()
+        public async Task AverageAwaitWithCancellationAsync_Selector_<#=t.Name#>_Nullable_Empty()
         {
             var ys = new <#=cs#>?[0].ToAsyncEnumerable();
-            Assert.Null(await ys.AverageAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None));
+            Assert.Null(await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None));
         }
 
         [Fact]
-        public async Task AverageAsync_AsyncSelectorWithCancellation_<#=t.Name#>_Nullable_Many()
+        public async Task AverageAwaitWithCancellationAsync_Selector_<#=t.Name#>_Nullable_Many()
         {
             var xs = new <#=cs#>?[] { 2, 3, 5, 7, 11, 13, 17, 19 };
             var ys = xs.ToAsyncEnumerable();
-            Assert.Equal(xs.Average(), await ys.AverageAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None));
         }
 #endif
 

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Average.cs

@@ -79,7 +79,7 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None).AsTask());
@@ -92,76 +92,76 @@ namespace Tests
 
             // Average<T>(IAE<T>, Func<T, VT<P>>)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x)).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x)).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>)).AsTask());
 
             // Average<T>(IAE<T>, Func<T, VT<P>>, CT)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>), CancellationToken.None).AsTask());
 
 #if !NO_DEEP_CANCELLATION
             // Average<T>(IAE<T>, Func<T, CT, VT<P>>, CT)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int>), (x, ct) => new ValueTask<int>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<int?>), (x, ct) => new ValueTask<int?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long>), (x, ct) => new ValueTask<long>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<long?>), (x, ct) => new ValueTask<long?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double>), (x, ct) => new ValueTask<double>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<double?>), (x, ct) => new ValueTask<double?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float>), (x, ct) => new ValueTask<float>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<float?>), (x, ct) => new ValueTask<float?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal>), (x, ct) => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(default(IAsyncEnumerable<decimal?>), (x, ct) => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<int>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<int?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<int>), (x, ct) => new ValueTask<int>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<int?>), (x, ct) => new ValueTask<int?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<long>), (x, ct) => new ValueTask<long>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<long?>), (x, ct) => new ValueTask<long?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<double>), (x, ct) => new ValueTask<double>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<double?>), (x, ct) => new ValueTask<double?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<float>), (x, ct) => new ValueTask<float>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<float?>), (x, ct) => new ValueTask<float?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<decimal>), (x, ct) => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(default(IAsyncEnumerable<decimal?>), (x, ct) => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<int?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.AverageAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal?>>), CancellationToken.None).AsTask());
 #endif
         }
 
@@ -172,7 +172,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Average(), await ys.AverageAsync());
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<int>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<int>(x)));
         }
 
         [Fact]
@@ -182,7 +182,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Average(), await ys.AverageAsync());
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<int?>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<int?>(x)));
         }
 
         [Fact]
@@ -192,7 +192,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Average(), await ys.AverageAsync());
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<long>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<long>(x)));
         }
 
         [Fact]
@@ -202,7 +202,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Average(), await ys.AverageAsync());
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<long?>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<long?>(x)));
         }
 
         [Fact]
@@ -212,7 +212,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Average(), await ys.AverageAsync());
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<double>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<double>(x)));
         }
 
         [Fact]
@@ -222,7 +222,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Average(), await ys.AverageAsync());
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<double?>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<double?>(x)));
         }
 
         [Fact]
@@ -232,7 +232,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Average(), await ys.AverageAsync());
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<float>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<float>(x)));
         }
 
         [Fact]
@@ -242,7 +242,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Average(), await ys.AverageAsync());
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<float?>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<float?>(x)));
         }
 
         [Fact]
@@ -252,7 +252,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Average(), await ys.AverageAsync());
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<decimal>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<decimal>(x)));
         }
 
         [Fact]
@@ -262,7 +262,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Average(), await ys.AverageAsync());
             Assert.Equal(xs.Average(), await ys.AverageAsync(x => x));
-            Assert.Equal(xs.Average(), await ys.AverageAsync(x => new ValueTask<decimal?>(x)));
+            Assert.Equal(xs.Average(), await ys.AverageAwaitAsync(x => new ValueTask<decimal?>(x)));
         }
 
         [Fact]

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Count.cs

@@ -40,7 +40,7 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, bool>)).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, x => true, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, bool>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
@@ -66,68 +66,68 @@ namespace Tests
         }
 
         [Fact]
-        public async Task CountAsync_AsyncPredicate_Null()
+        public async Task CountAwaitAsync_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAwaitAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAwaitAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAwaitAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAwaitAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task CountAsync_AsyncPredicate()
+        public async Task CountAwaitAsync()
         {
-            Assert.Equal(0, await new int[0].ToAsyncEnumerable().CountAsync(x => new ValueTask<bool>(x < 3)));
-            Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAsync(x => new ValueTask<bool>(x < 3)));
+            Assert.Equal(0, await new int[0].ToAsyncEnumerable().CountAwaitAsync(x => new ValueTask<bool>(x < 3)));
+            Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAwaitAsync(x => new ValueTask<bool>(x < 3)));
         }
 
         [Fact]
-        public async Task CountAsync_AsyncPredicate_Throws_Predicate()
+        public async Task CountAwaitAsync_Throws_Predicate()
         {
             var ex = new Exception("Bang!");
-            var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAsync(new Func<int, ValueTask<bool>>(x => { throw ex; }));
+            var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAwaitAsync(new Func<int, ValueTask<bool>>(x => { throw ex; }));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task CountAsync_AsyncPredicate_Throws_Source()
+        public async Task CountAwaitAsync_Throws_Source()
         {
             var ex = new Exception("Bang!");
-            await AssertThrowsAsync(Throw<int>(ex).CountAsync(x => new ValueTask<bool>(x < 3)), ex);
+            await AssertThrowsAsync(Throw<int>(ex).CountAwaitAsync(x => new ValueTask<bool>(x < 3)), ex);
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task CountAsync_AsyncPredicateCancel_Null()
+        public async Task CountAwaitWithCancellationAsync_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, (x, ct) => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAwaitWithCancellationAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.CountAwaitWithCancellationAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task CountAsync_AsyncPredicateCancel()
+        public async Task CountAwaitWithCancellationAsync()
         {
-            Assert.Equal(0, await new int[0].ToAsyncEnumerable().CountAsync((x, ct) => new ValueTask<bool>(x < 3)));
-            Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAsync((x, ct) => new ValueTask<bool>(x < 3)));
+            Assert.Equal(0, await new int[0].ToAsyncEnumerable().CountAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x < 3)));
+            Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x < 3)));
         }
 
         [Fact]
-        public async Task CountAsync_AsyncPredicateCancel_Throws_Predicate()
+        public async Task CountAwaitWithCancellationAsync_Throws_Predicate()
         {
             var ex = new Exception("Bang!");
-            var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAsync(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
+            var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAwaitWithCancellationAsync(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task CountAsync_AsyncPredicateCancel_Throws_Source()
+        public async Task CountAwaitWithCancellationAsync_Throws_Source()
         {
             var ex = new Exception("Bang!");
-            await AssertThrowsAsync(Throw<int>(ex).CountAsync((x, ct) => new ValueTask<bool>(x < 3)), ex);
+            await AssertThrowsAsync(Throw<int>(ex).CountAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x < 3)), ex);
         }
 #endif
     }

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/First.cs

@@ -23,17 +23,17 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAsync(Return42, default(Func<int, bool>)).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAsync<int>(default, x => true, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAsync(Return42, default(Func<int, bool>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAsync(Return42, default, CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAsync(Return42, default(Func<int, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAwaitAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAwaitAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAsync(Return42, default(Func<int, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAwaitAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAwaitAsync(Return42, default, CancellationToken.None).AsTask());
 
 #if !NO_DEEP_CANCELLATION
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstAwaitWithCancellationAsync(Return42, default, CancellationToken.None).AsTask());
 #endif
         }
 
@@ -173,159 +173,159 @@ namespace Tests
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicate_Empty()
+        public async Task FirstAwaitAsync_Predicate_Empty()
         {
-            var res = AsyncEnumerable.Empty<int>().FirstAsync(x => new ValueTask<bool>(true));
+            var res = AsyncEnumerable.Empty<int>().FirstAwaitAsync(x => new ValueTask<bool>(true));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicate_Throw()
+        public async Task FirstAwaitAsync_Predicate_Throw()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).FirstAsync(x => new ValueTask<bool>(true));
+            var res = Throw<int>(ex).FirstAwaitAsync(x => new ValueTask<bool>(true));
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicate_Single_None()
+        public async Task FirstAwaitAsync_Predicate_Single_None()
         {
-            var res = Return42.FirstAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = Return42.FirstAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicate_Many_IList_None()
+        public async Task FirstAwaitAsync_Predicate_Many_IList_None()
         {
-            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().FirstAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().FirstAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicate_Many_None()
+        public async Task FirstAwaitAsync_Predicate_Many_None()
         {
-            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().Select(x => x).FirstAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().Select(x => x).FirstAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicate_Single_Pass()
+        public async Task FirstAwaitAsync_Predicate_Single_Pass()
         {
-            var res = Return42.FirstAsync(x => new ValueTask<bool>(x % 2 == 0));
+            var res = Return42.FirstAwaitAsync(x => new ValueTask<bool>(x % 2 == 0));
             Assert.Equal(42, await res);
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicate_Many_IList_Pass1()
+        public async Task FirstAwaitAsync_Predicate_Many_IList_Pass1()
         {
-            var res = new[] { 42, 43, 44 }.ToAsyncEnumerable().FirstAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 43, 44 }.ToAsyncEnumerable().FirstAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(43, await res);
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicate_Many_IList_Pass2()
+        public async Task FirstAwaitAsync_Predicate_Many_IList_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicate_Many_Pass1()
+        public async Task FirstAwaitAsync_Predicate_Many_Pass1()
         {
-            var res = new[] { 42, 43, 44 }.Select(x => x).ToAsyncEnumerable().FirstAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 43, 44 }.Select(x => x).ToAsyncEnumerable().FirstAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(43, await res);
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicate_Many_Pass2()
+        public async Task FirstAwaitAsync_Predicate_Many_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.Select(x => x).ToAsyncEnumerable().FirstAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 45, 90 }.Select(x => x).ToAsyncEnumerable().FirstAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicate_AsyncPredicateThrows()
+        public async Task FirstAwaitAsync_Predicate_AsyncPredicateThrows()
         {
-            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().FirstAsync(x => new ValueTask<bool>(1 / x > 0));
+            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().FirstAwaitAsync(x => new ValueTask<bool>(1 / x > 0));
             await AssertThrowsAsync<DivideByZeroException>(res.AsTask());
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task FirstAsync_AsyncPredicateWithCancellation_Empty()
+        public async Task FirstAwaitWithCancellationAsync_Predicate_Empty()
         {
-            var res = AsyncEnumerable.Empty<int>().FirstAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
+            var res = AsyncEnumerable.Empty<int>().FirstAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicateWithCancellation_Throw()
+        public async Task FirstAwaitWithCancellationAsync_Predicate_Throw()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).FirstAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
+            var res = Throw<int>(ex).FirstAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicateWithCancellation_Single_None()
+        public async Task FirstAwaitWithCancellationAsync_Predicate_Single_None()
         {
-            var res = Return42.FirstAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = Return42.FirstAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicateWithCancellation_Many_IList_None()
+        public async Task FirstAwaitWithCancellationAsync_Predicate_Many_IList_None()
         {
-            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().FirstAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().FirstAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicateWithCancellation_Many_None()
+        public async Task FirstAwaitWithCancellationAsync_Predicate_Many_None()
         {
-            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().Select((x, ct) => x).FirstAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().Select((x, ct) => x).FirstAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicateWithCancellation_Single_Pass()
+        public async Task FirstAwaitWithCancellationAsync_Predicate_Single_Pass()
         {
-            var res = Return42.FirstAsync((x, ct) => new ValueTask<bool>(x % 2 == 0), CancellationToken.None);
+            var res = Return42.FirstAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 == 0), CancellationToken.None);
             Assert.Equal(42, await res);
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicateWithCancellation_Many_IList_Pass1()
+        public async Task FirstAwaitWithCancellationAsync_Predicate_Many_IList_Pass1()
         {
-            var res = new[] { 42, 43, 44 }.ToAsyncEnumerable().FirstAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 42, 43, 44 }.ToAsyncEnumerable().FirstAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(43, await res);
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicateWithCancellation_Many_IList_Pass2()
+        public async Task FirstAwaitWithCancellationAsync_Predicate_Many_IList_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicateWithCancellation_Many_Pass1()
+        public async Task FirstAwaitWithCancellationAsync_Predicate_Many_Pass1()
         {
-            var res = new[] { 42, 43, 44 }.Select((x, ct) => x).ToAsyncEnumerable().FirstAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 42, 43, 44 }.Select((x, ct) => x).ToAsyncEnumerable().FirstAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(43, await res);
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicateWithCancellation_Many_Pass2()
+        public async Task FirstAwaitWithCancellationAsync_Predicate_Many_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.Select((x, ct) => x).ToAsyncEnumerable().FirstAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 42, 45, 90 }.Select((x, ct) => x).ToAsyncEnumerable().FirstAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task FirstAsync_AsyncPredicateWithCancellation_AsyncPredicateWithCancellationThrows()
+        public async Task FirstAwaitWithCancellationAsync_Predicate_AsyncPredicateWithCancellationThrows()
         {
-            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().FirstAsync((x, ct) => new ValueTask<bool>(1 / x > 0), CancellationToken.None);
+            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().FirstAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(1 / x > 0), CancellationToken.None);
             await AssertThrowsAsync<DivideByZeroException>(res.AsTask());
         }
 #endif

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/FirstOrDefault.cs

@@ -23,17 +23,17 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync(Return42, default(Func<int, bool>)).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync<int>(default, x => true, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync(Return42, default(Func<int, bool>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync(Return42, default, CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync(Return42, default(Func<int, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAwaitAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAwaitAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync(Return42, default(Func<int, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAwaitAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAwaitAsync(Return42, default, CancellationToken.None).AsTask());
 
 #if !NO_DEEP_CANCELLATION
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.FirstOrDefaultAwaitWithCancellationAsync(Return42, default, CancellationToken.None).AsTask());
 #endif
         }
 
@@ -174,159 +174,159 @@ namespace Tests
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicate_Empty()
+        public async Task FirstOrDefaultAwaitAsync_Predicate_Empty()
         {
-            var res = AsyncEnumerable.Empty<int>().FirstOrDefaultAsync(x => new ValueTask<bool>(true));
+            var res = AsyncEnumerable.Empty<int>().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(true));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicate_Throw()
+        public async Task FirstOrDefaultAwaitAsync_Predicate_Throw()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).FirstOrDefaultAsync(x => new ValueTask<bool>(true));
+            var res = Throw<int>(ex).FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(true));
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicate_Single_None()
+        public async Task FirstOrDefaultAwaitAsync_Predicate_Single_None()
         {
-            var res = Return42.FirstOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = Return42.FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicate_Many_IList_None()
+        public async Task FirstOrDefaultAwaitAsync_Predicate_Many_IList_None()
         {
-            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().FirstOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicate_Many_None()
+        public async Task FirstOrDefaultAwaitAsync_Predicate_Many_None()
         {
-            var res = new[] { 40, 42, 44 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 40, 42, 44 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicate_Single_Pass()
+        public async Task FirstOrDefaultAwaitAsync_Predicate_Single_Pass()
         {
-            var res = Return42.FirstOrDefaultAsync(x => new ValueTask<bool>(x % 2 == 0));
+            var res = Return42.FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 == 0));
             Assert.Equal(42, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicate_Many_IList_Pass1()
+        public async Task FirstOrDefaultAwaitAsync_Predicate_Many_IList_Pass1()
         {
-            var res = new[] { 42, 43, 44 }.ToAsyncEnumerable().FirstOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 43, 44 }.ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(43, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicate_Many_IList_Pass2()
+        public async Task FirstOrDefaultAwaitAsync_Predicate_Many_IList_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicate_Many_Pass1()
+        public async Task FirstOrDefaultAwaitAsync_Predicate_Many_Pass1()
         {
-            var res = new[] { 42, 43, 44 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 43, 44 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(43, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicate_Many_Pass2()
+        public async Task FirstOrDefaultAwaitAsync_Predicate_Many_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 45, 90 }.Select(x => x).ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicate_AsyncPredicateThrows()
+        public async Task FirstOrDefaultAwaitAsync_Predicate_AsyncPredicateThrows()
         {
-            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().FirstOrDefaultAsync(x => new ValueTask<bool>(1 / x > 0));
+            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().FirstOrDefaultAwaitAsync(x => new ValueTask<bool>(1 / x > 0));
             await AssertThrowsAsync<DivideByZeroException>(res.AsTask());
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicateWithCancellation_Empty()
+        public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Empty()
         {
-            var res = AsyncEnumerable.Empty<int>().FirstOrDefaultAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
+            var res = AsyncEnumerable.Empty<int>().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicateWithCancellation_Throw()
+        public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Throw()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).FirstOrDefaultAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
+            var res = Throw<int>(ex).FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicateWithCancellation_Single_None()
+        public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Single_None()
         {
-            var res = Return42.FirstOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = Return42.FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicateWithCancellation_Many_IList_None()
+        public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Many_IList_None()
         {
-            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().FirstOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicateWithCancellation_Many_None()
+        public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Many_None()
         {
-            var res = new[] { 40, 42, 44 }.Select((x, ct) => x).ToAsyncEnumerable().FirstOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 40, 42, 44 }.Select((x, ct) => x).ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicateWithCancellation_Single_Pass()
+        public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Single_Pass()
         {
-            var res = Return42.FirstOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 == 0), CancellationToken.None);
+            var res = Return42.FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 == 0), CancellationToken.None);
             Assert.Equal(42, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicateWithCancellation_Many_IList_Pass1()
+        public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Many_IList_Pass1()
         {
-            var res = new[] { 42, 43, 44 }.ToAsyncEnumerable().FirstOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 42, 43, 44 }.ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(43, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicateWithCancellation_Many_IList_Pass2()
+        public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Many_IList_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicateWithCancellation_Many_Pass1()
+        public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Many_Pass1()
         {
-            var res = new[] { 42, 43, 44 }.Select((x, ct) => x).ToAsyncEnumerable().FirstOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 42, 43, 44 }.Select((x, ct) => x).ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(43, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicateWithCancellation_Many_Pass2()
+        public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_Many_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.Select((x, ct) => x).ToAsyncEnumerable().FirstOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 42, 45, 90 }.Select((x, ct) => x).ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task FirstOrDefaultAsync_AsyncPredicateWithCancellation_AsyncPredicateWithCancellationThrows()
+        public async Task FirstOrDefaultAwaitWithCancellationAsync_Predicate_AsyncPredicateWithCancellationThrows()
         {
-            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().FirstOrDefaultAsync((x, ct) => new ValueTask<bool>(1 / x > 0), CancellationToken.None);
+            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().FirstOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(1 / x > 0), CancellationToken.None);
             await AssertThrowsAsync<DivideByZeroException>(res.AsTask());
         }
 #endif

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ForEachAsync.cs

@@ -14,7 +14,7 @@ namespace Tests
     public class ForEachAsync : AsyncEnumerableTests
     {
         [Fact]
-        public async Task ForEachAsync_Sync_Null()
+        public async Task ForEachAsync_Null()
         {
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(default, x => { }));
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync(Return42, default(Action<int>)));
@@ -28,7 +28,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task ForEachAsync_Sync_Simple()
+        public async Task ForEachAsync_Simple()
         {
             var sum = 0;
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -38,7 +38,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task ForEachAsync_Sync_Indexed()
+        public async Task ForEachAsync_Indexed()
         {
             var sum = 0;
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -48,7 +48,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task ForEachAsync_Sync_Throws_Action()
+        public async Task ForEachAsync_Throws_Action()
         {
             var ex = new Exception("Bang");
             var xs = Throw<int>(ex);
@@ -57,7 +57,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task ForEachAsync_Sync_Indexed_Throws_Action()
+        public async Task ForEachAsync_Indexed_Throws_Action()
         {
             var ex = new Exception("Bang");
             var xs = Throw<int>(ex);
@@ -65,44 +65,42 @@ namespace Tests
             await AssertThrowsAsync(xs.ForEachAsync((int x, int i) => { throw ex; }), ex);
         }
 
-        // REVIEW: Overloads with (T, int) and (T, CancellationToken) cause ambiguity.
-
         [Fact]
-        public async Task ForEachAsync_Async_Null()
+        public async Task ForEachAwaitAsync_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(default, x => Task.CompletedTask));
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync(Return42, default(Func<int, Task>)));
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(default, (x, i) => Task.CompletedTask));
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync(Return42, default(Func<int, int, Task>)));
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(default, x => Task.CompletedTask, CancellationToken.None));
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync(Return42, default(Func<int, Task>), CancellationToken.None));
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync(default, (int x, int i) => Task.CompletedTask, CancellationToken.None));
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync(Return42, default(Func<int, int, Task>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAwaitAsync<int>(default, x => Task.CompletedTask));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAwaitAsync(Return42, default(Func<int, Task>)));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAwaitAsync<int>(default, (x, i) => Task.CompletedTask));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAwaitAsync(Return42, default(Func<int, int, Task>)));
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAwaitAsync<int>(default, x => Task.CompletedTask, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAwaitAsync(Return42, default(Func<int, Task>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAwaitAsync(default, (int x, int i) => Task.CompletedTask, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAwaitAsync(Return42, default(Func<int, int, Task>), CancellationToken.None));
         }
 
         [Fact]
-        public async Task ForEachAsync_Async_Simple()
+        public async Task ForEachAwaitAsync_Simple()
         {
             var sum = 0;
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
 
-            await xs.ForEachAsync(x => { sum += x; return Task.CompletedTask; });
+            await xs.ForEachAwaitAsync(x => { sum += x; return Task.CompletedTask; });
             Assert.Equal(10, sum);
         }
 
         [Fact]
-        public async Task ForEachAsync_Async_Indexed()
+        public async Task ForEachAwaitAsync_Indexed()
         {
             var sum = 0;
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
 
-            await xs.ForEachAsync((x, i) => { sum += x * i; return Task.CompletedTask; });
+            await xs.ForEachAwaitAsync((x, i) => { sum += x * i; return Task.CompletedTask; });
             Assert.Equal(1 * 0 + 2 * 1 + 3 * 2 + 4 * 3, sum);
         }
 
         [Fact]
-        public async Task ForEachAsync_Async_Throws_Action()
+        public async Task ForEachAwaitAsync_Throws_Action()
         {
             var ex = new Exception("Bang");
             var xs = Throw<int>(ex);
@@ -111,7 +109,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task ForEachAsync_Async_Indexed_Throws_Action()
+        public async Task ForEachAwaitAsync_Indexed_Throws_Action()
         {
             var ex = new Exception("Bang");
             var xs = Throw<int>(ex);
@@ -120,50 +118,50 @@ namespace Tests
         }
 
         [Fact]
-        public async Task ForEachAsync_Cancel_Async_Cancel_Null()
+        public async Task ForEachAwaitWithCancellationAsync_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync(default, (int x, CancellationToken ct) => Task.CompletedTask, CancellationToken.None));
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync(Return42, default(Func<int, CancellationToken, Task>), CancellationToken.None));
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync<int>(default, (x, i, ct) => Task.CompletedTask, CancellationToken.None));
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAsync(Return42, default(Func<int, int, CancellationToken, Task>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAwaitWithCancellationAsync(default, (int x, CancellationToken ct) => Task.CompletedTask, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAwaitWithCancellationAsync(Return42, default(Func<int, CancellationToken, Task>), CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAwaitWithCancellationAsync<int>(default, (x, i, ct) => Task.CompletedTask, CancellationToken.None));
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ForEachAwaitWithCancellationAsync(Return42, default(Func<int, int, CancellationToken, Task>), CancellationToken.None));
         }
 
         [Fact]
-        public async Task ForEachAsync_Cancel_Async_Cancel_Simple()
+        public async Task ForEachAwaitWithCancellationAsync_Simple()
         {
             var sum = 0;
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
 
-            await xs.ForEachAsync((int x, CancellationToken ct) => { sum += x; return Task.CompletedTask; }, CancellationToken.None);
+            await xs.ForEachAwaitWithCancellationAsync((int x, CancellationToken ct) => { sum += x; return Task.CompletedTask; }, CancellationToken.None);
             Assert.Equal(10, sum);
         }
 
         [Fact]
-        public async Task ForEachAsync_Cancel_Async_Cancel_Indexed()
+        public async Task ForEachAwaitWithCancellationAsync_Indexed()
         {
             var sum = 0;
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
 
-            await xs.ForEachAsync((x, i, ct) => { sum += x * i; return Task.CompletedTask; }, CancellationToken.None);
+            await xs.ForEachAwaitWithCancellationAsync((x, i, ct) => { sum += x * i; return Task.CompletedTask; }, CancellationToken.None);
             Assert.Equal(1 * 0 + 2 * 1 + 3 * 2 + 4 * 3, sum);
         }
 
         [Fact]
-        public async Task ForEachAsync_Cancel_Async_Cancel_Throws_Action()
+        public async Task ForEachAwaitWithCancellationAsync_Throws_Action()
         {
             var ex = new Exception("Bang");
             var xs = Throw<int>(ex);
 
-            await AssertThrowsAsync(xs.ForEachAsync((int x, CancellationToken ct) => Task.FromException(ex), CancellationToken.None), ex);
+            await AssertThrowsAsync(xs.ForEachAwaitWithCancellationAsync((int x, CancellationToken ct) => Task.FromException(ex), CancellationToken.None), ex);
         }
 
         [Fact]
-        public async Task ForEachAsync_Cancel_Async_Cancel_Indexed_Throws_Action()
+        public async Task ForEachAwaitWithCancellationAsync_Indexed_Throws_Action()
         {
             var ex = new Exception("Bang");
             var xs = Throw<int>(ex);
 
-            await AssertThrowsAsync(xs.ForEachAsync((x, i, ct) => Task.FromException(ex), CancellationToken.None), ex);
+            await AssertThrowsAsync(xs.ForEachAwaitWithCancellationAsync((x, i, ct) => Task.FromException(ex), CancellationToken.None), ex);
         }
     }
 }

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/GroupBy.Generated.cs

@@ -184,8 +184,8 @@ namespace Tests
         [Fact]
         public void KeySelector_Async_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(Return42, default(Func<int, ValueTask<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int>(Return42, default(Func<int, ValueTask<int>>)));
         }
 
         [Fact]
@@ -195,7 +195,7 @@ namespace Tests
             var methodsA = methodsS.ToAsyncEnumerable();
 
             var resS = methodsS.GroupBy(m => m.Name);
-            var resA = methodsA.GroupBy(m => new ValueTask<string>(m.Name));
+            var resA = methodsA.GroupByAwait(m => new ValueTask<string>(m.Name));
 
             await Groups_AssertCore(resS, resA);
         }
@@ -203,8 +203,8 @@ namespace Tests
         [Fact]
         public void KeySelector_Async_Comparer_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(Return42, default(Func<int, ValueTask<int>>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int>(Return42, default(Func<int, ValueTask<int>>), EqualityComparer<int>.Default));
         }
 
         [Fact]
@@ -216,7 +216,7 @@ namespace Tests
             var eq = new StringPrefixEqualityComparer(1);
 
             var resS = methodsS.GroupBy(m => m.Name, eq);
-            var resA = methodsA.GroupBy(m => new ValueTask<string>(m.Name), eq);
+            var resA = methodsA.GroupByAwait(m => new ValueTask<string>(m.Name), eq);
 
             await Groups_AssertCore(resS, resA);
         }
@@ -224,9 +224,9 @@ namespace Tests
         [Fact]
         public void KeySelector_ElementSelector_Async_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (int x) => new ValueTask<int>(x)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default(Func<int, ValueTask<int>>), (int x) => new ValueTask<int>(x)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, (int x) => new ValueTask<int>(x), default(Func<int, ValueTask<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (int x) => new ValueTask<int>(x)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int>(Return42, default(Func<int, ValueTask<int>>), (int x) => new ValueTask<int>(x)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int>(Return42, (int x) => new ValueTask<int>(x), default(Func<int, ValueTask<int>>)));
         }
 
         [Fact]
@@ -236,7 +236,7 @@ namespace Tests
             var methodsA = methodsS.ToAsyncEnumerable();
 
             var resS = methodsS.GroupBy(m => m.Name, m => m.Name.ToUpper());
-            var resA = methodsA.GroupBy(m => new ValueTask<string>(m.Name), m => new ValueTask<string>(m.Name.ToUpper()));
+            var resA = methodsA.GroupByAwait(m => new ValueTask<string>(m.Name), m => new ValueTask<string>(m.Name.ToUpper()));
 
             await Groups_AssertCore(resS, resA);
         }
@@ -244,9 +244,9 @@ namespace Tests
         [Fact]
         public void KeySelector_ElementSelector_Async_Comparer_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (int x) => new ValueTask<int>(x), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default(Func<int, ValueTask<int>>), (int x) => new ValueTask<int>(x), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), default(Func<int, ValueTask<int>>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (int x) => new ValueTask<int>(x), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int>(Return42, default(Func<int, ValueTask<int>>), (int x) => new ValueTask<int>(x), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), default(Func<int, ValueTask<int>>), EqualityComparer<int>.Default));
         }
 
         [Fact]
@@ -258,7 +258,7 @@ namespace Tests
             var eq = new StringPrefixEqualityComparer(1);
 
             var resS = methodsS.GroupBy(m => m.Name, m => m.Name.ToUpper(), eq);
-            var resA = methodsA.GroupBy(m => new ValueTask<string>(m.Name), m => new ValueTask<string>(m.Name.ToUpper()), eq);
+            var resA = methodsA.GroupByAwait(m => new ValueTask<string>(m.Name), m => new ValueTask<string>(m.Name.ToUpper()), eq);
 
             await Groups_AssertCore(resS, resA);
         }
@@ -266,9 +266,9 @@ namespace Tests
         [Fact]
         public void KeySelector_ResultSelector_Async_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (k, g) => new ValueTask<int>(0)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default(Func<int, ValueTask<int>>), (k, g) => new ValueTask<int>(0)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, (int x) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, ValueTask<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (k, g) => new ValueTask<int>(0)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int>(Return42, default(Func<int, ValueTask<int>>), (k, g) => new ValueTask<int>(0)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int>(Return42, (int x) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, ValueTask<int>>)));
         }
 
         [Fact]
@@ -278,7 +278,7 @@ namespace Tests
             var methodsA = methodsS.ToAsyncEnumerable();
 
             var resS = methodsS.GroupBy(m => m.Name, (k, g) => k + " - " + g.Count());
-            var resA = methodsA.GroupBy<System.Reflection.MethodInfo, string, string>(m => new ValueTask<string>(m.Name), async (k, g) => k + " - " + await g.CountAsync()); // REVIEW: Ambiguity
+            var resA = methodsA.GroupByAwait(m => new ValueTask<string>(m.Name), async (k, g) => k + " - " + await g.CountAsync());
 
             await Group_Result_AssertCore(resS, resA);
         }
@@ -286,9 +286,9 @@ namespace Tests
         [Fact]
         public void KeySelector_ResultSelector_Async_Comparer_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (k, g) => new ValueTask<int>(0), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default(Func<int, ValueTask<int>>), (k, g) => new ValueTask<int>(0), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, ValueTask<int>>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (k, g) => new ValueTask<int>(0), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int>(Return42, default(Func<int, ValueTask<int>>), (k, g) => new ValueTask<int>(0), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, ValueTask<int>>), EqualityComparer<int>.Default));
         }
 
         [Fact]
@@ -300,7 +300,7 @@ namespace Tests
             var eq = new StringPrefixEqualityComparer(1);
 
             var resS = methodsS.GroupBy(m => m.Name, (k, g) => k + " - " + g.Count(), eq);
-            var resA = methodsA.GroupBy(m => new ValueTask<string>(m.Name), async (k, g) => k + " - " + await g.CountAsync(), eq);
+            var resA = methodsA.GroupByAwait(m => new ValueTask<string>(m.Name), async (k, g) => k + " - " + await g.CountAsync(), eq);
 
             await Group_Result_AssertCore(resS, resA);
         }
@@ -308,10 +308,10 @@ namespace Tests
         [Fact]
         public void KeySelector_ElementSelector_ResultSelector_Async_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (int x) => new ValueTask<int>(x), (k, g) => new ValueTask<int>(0)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, default(Func<int, ValueTask<int>>), (int x) => new ValueTask<int>(x), (k, g) => new ValueTask<int>(0)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, (int x) => new ValueTask<int>(x), default(Func<int, ValueTask<int>>), (k, g) => new ValueTask<int>(0)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, (int x) => new ValueTask<int>(x), (int x) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, ValueTask<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (int x) => new ValueTask<int>(x), (k, g) => new ValueTask<int>(0)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int, int>(Return42, default(Func<int, ValueTask<int>>), (int x) => new ValueTask<int>(x), (k, g) => new ValueTask<int>(0)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int, int>(Return42, (int x) => new ValueTask<int>(x), default(Func<int, ValueTask<int>>), (k, g) => new ValueTask<int>(0)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int, int>(Return42, (int x) => new ValueTask<int>(x), (int x) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, ValueTask<int>>)));
         }
 
         [Fact]
@@ -321,7 +321,7 @@ namespace Tests
             var methodsA = methodsS.ToAsyncEnumerable();
 
             var resS = methodsS.GroupBy(m => m.Name, m => m.Name.ToUpper(), (k, g) => k + " - " + g.Count());
-            var resA = methodsA.GroupBy<System.Reflection.MethodInfo, string, string, string>(m => new ValueTask<string>(m.Name), m => new ValueTask<string>(m.Name.ToUpper()), async (k, g) => k + " - " + await g.CountAsync()); // REVIEW: Ambiguity
+            var resA = methodsA.GroupByAwait(m => new ValueTask<string>(m.Name), m => new ValueTask<string>(m.Name.ToUpper()), async (k, g) => k + " - " + await g.CountAsync());
 
             await Group_Result_AssertCore(resS, resA);
         }
@@ -329,10 +329,10 @@ namespace Tests
         [Fact]
         public void KeySelector_ElementSelector_ResultSelector_Async_Comparer_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (int x) => new ValueTask<int>(x), (k, g) => new ValueTask<int>(0), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, default(Func<int, ValueTask<int>>), (int x) => new ValueTask<int>(x), (k, g) => new ValueTask<int>(0), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), default(Func<int, ValueTask<int>>), (k, g) => new ValueTask<int>(0), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (int x) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, ValueTask<int>>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (int x) => new ValueTask<int>(x), (k, g) => new ValueTask<int>(0), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int, int>(Return42, default(Func<int, ValueTask<int>>), (int x) => new ValueTask<int>(x), (k, g) => new ValueTask<int>(0), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), default(Func<int, ValueTask<int>>), (k, g) => new ValueTask<int>(0), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwait<int, int, int, int>(default(IAsyncEnumerable<int>), (int x) => new ValueTask<int>(x), (int x) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, ValueTask<int>>), EqualityComparer<int>.Default));
         }
 
         [Fact]
@@ -344,7 +344,7 @@ namespace Tests
             var eq = new StringPrefixEqualityComparer(1);
 
             var resS = methodsS.GroupBy(m => m.Name, m => m.Name.ToUpper(), (k, g) => k + " - " + g.Count(), eq);
-            var resA = methodsA.GroupBy(m => new ValueTask<string>(m.Name), m => new ValueTask<string>(m.Name.ToUpper()), async (k, g) => k + " - " + await g.CountAsync(), eq);
+            var resA = methodsA.GroupByAwait(m => new ValueTask<string>(m.Name), m => new ValueTask<string>(m.Name.ToUpper()), async (k, g) => k + " - " + await g.CountAsync(), eq);
 
             await Group_Result_AssertCore(resS, resA);
         }
@@ -353,8 +353,8 @@ namespace Tests
         [Fact]
         public void KeySelector_Async_Cancel_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>)));
         }
 
         [Fact]
@@ -364,7 +364,7 @@ namespace Tests
             var methodsA = methodsS.ToAsyncEnumerable();
 
             var resS = methodsS.GroupBy(m => m.Name);
-            var resA = methodsA.GroupBy((m, ct) => new ValueTask<string>(m.Name));
+            var resA = methodsA.GroupByAwaitWithCancellation((m, ct) => new ValueTask<string>(m.Name));
 
             await Groups_AssertCore(resS, resA);
         }
@@ -372,8 +372,8 @@ namespace Tests
         [Fact]
         public void KeySelector_Async_Cancel_Comparer_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), EqualityComparer<int>.Default));
         }
 
         [Fact]
@@ -385,7 +385,7 @@ namespace Tests
             var eq = new StringPrefixEqualityComparer(1);
 
             var resS = methodsS.GroupBy(m => m.Name, eq);
-            var resA = methodsA.GroupBy((m, ct) => new ValueTask<string>(m.Name), eq);
+            var resA = methodsA.GroupByAwaitWithCancellation((m, ct) => new ValueTask<string>(m.Name), eq);
 
             await Groups_AssertCore(resS, resA);
         }
@@ -393,9 +393,9 @@ namespace Tests
         [Fact]
         public void KeySelector_ElementSelector_Async_Cancel_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (int x, CancellationToken ct) => new ValueTask<int>(x)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), (int x, CancellationToken ct) => new ValueTask<int>(x)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, CancellationToken, ValueTask<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (int x, CancellationToken ct) => new ValueTask<int>(x)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), (int x, CancellationToken ct) => new ValueTask<int>(x)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int>(Return42, (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, CancellationToken, ValueTask<int>>)));
         }
 
         [Fact]
@@ -405,7 +405,7 @@ namespace Tests
             var methodsA = methodsS.ToAsyncEnumerable();
 
             var resS = methodsS.GroupBy(m => m.Name, m => m.Name.ToUpper());
-            var resA = methodsA.GroupBy((m, ct) => new ValueTask<string>(m.Name), (m, ct) => new ValueTask<string>(m.Name.ToUpper()));
+            var resA = methodsA.GroupByAwaitWithCancellation((m, ct) => new ValueTask<string>(m.Name), (m, ct) => new ValueTask<string>(m.Name.ToUpper()));
 
             await Groups_AssertCore(resS, resA);
         }
@@ -413,9 +413,9 @@ namespace Tests
         [Fact]
         public void KeySelector_ElementSelector_Async_Cancel_Comparer_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (int x, CancellationToken ct) => new ValueTask<int>(x), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), (int x, CancellationToken ct) => new ValueTask<int>(x), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, CancellationToken, ValueTask<int>>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (int x, CancellationToken ct) => new ValueTask<int>(x), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), (int x, CancellationToken ct) => new ValueTask<int>(x), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, CancellationToken, ValueTask<int>>), EqualityComparer<int>.Default));
         }
 
         [Fact]
@@ -427,7 +427,7 @@ namespace Tests
             var eq = new StringPrefixEqualityComparer(1);
 
             var resS = methodsS.GroupBy(m => m.Name, m => m.Name.ToUpper(), eq);
-            var resA = methodsA.GroupBy((m, ct) => new ValueTask<string>(m.Name), (m, ct) => new ValueTask<string>(m.Name.ToUpper()), eq);
+            var resA = methodsA.GroupByAwaitWithCancellation((m, ct) => new ValueTask<string>(m.Name), (m, ct) => new ValueTask<string>(m.Name.ToUpper()), eq);
 
             await Groups_AssertCore(resS, resA);
         }
@@ -435,9 +435,9 @@ namespace Tests
         [Fact]
         public void KeySelector_ResultSelector_Async_Cancel_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (k, g, ct) => new ValueTask<int>(0)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), (k, g, ct) => new ValueTask<int>(0)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, CancellationToken, ValueTask<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (k, g, ct) => new ValueTask<int>(0)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), (k, g, ct) => new ValueTask<int>(0)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int>(Return42, (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, CancellationToken, ValueTask<int>>)));
         }
 
         [Fact]
@@ -447,7 +447,7 @@ namespace Tests
             var methodsA = methodsS.ToAsyncEnumerable();
 
             var resS = methodsS.GroupBy(m => m.Name, (k, g) => k + " - " + g.Count());
-            var resA = methodsA.GroupBy((m, ct) => new ValueTask<string>(m.Name), async (k, g, ct) => k + " - " + await g.CountAsync(ct));
+            var resA = methodsA.GroupByAwaitWithCancellation((m, ct) => new ValueTask<string>(m.Name), async (k, g, ct) => k + " - " + await g.CountAsync(ct));
 
             await Group_Result_AssertCore(resS, resA);
         }
@@ -455,9 +455,9 @@ namespace Tests
         [Fact]
         public void KeySelector_ResultSelector_Async_Cancel_Comparer_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (k, g, ct) => new ValueTask<int>(0), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), (k, g, ct) => new ValueTask<int>(0), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, CancellationToken, ValueTask<int>>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (k, g, ct) => new ValueTask<int>(0), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), (k, g, ct) => new ValueTask<int>(0), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, CancellationToken, ValueTask<int>>), EqualityComparer<int>.Default));
         }
 
         [Fact]
@@ -469,7 +469,7 @@ namespace Tests
             var eq = new StringPrefixEqualityComparer(1);
 
             var resS = methodsS.GroupBy(m => m.Name, (k, g) => k + " - " + g.Count(), eq);
-            var resA = methodsA.GroupBy((m, ct) => new ValueTask<string>(m.Name), async (k, g, ct) => k + " - " + await g.CountAsync(ct), eq);
+            var resA = methodsA.GroupByAwaitWithCancellation((m, ct) => new ValueTask<string>(m.Name), async (k, g, ct) => k + " - " + await g.CountAsync(ct), eq);
 
             await Group_Result_AssertCore(resS, resA);
         }
@@ -477,10 +477,10 @@ namespace Tests
         [Fact]
         public void KeySelector_ElementSelector_ResultSelector_Async_Cancel_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (int x, CancellationToken ct) => new ValueTask<int>(x), (k, g, ct) => new ValueTask<int>(0)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), (int x, CancellationToken ct) => new ValueTask<int>(x), (k, g, ct) => new ValueTask<int>(0)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, CancellationToken, ValueTask<int>>), (k, g, ct) => new ValueTask<int>(0)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, (int x, CancellationToken ct) => new ValueTask<int>(x), (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, CancellationToken, ValueTask<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (int x, CancellationToken ct) => new ValueTask<int>(x), (k, g, ct) => new ValueTask<int>(0)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), (int x, CancellationToken ct) => new ValueTask<int>(x), (k, g, ct) => new ValueTask<int>(0)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int, int>(Return42, (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, CancellationToken, ValueTask<int>>), (k, g, ct) => new ValueTask<int>(0)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int, int>(Return42, (int x, CancellationToken ct) => new ValueTask<int>(x), (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, CancellationToken, ValueTask<int>>)));
         }
 
         [Fact]
@@ -490,7 +490,7 @@ namespace Tests
             var methodsA = methodsS.ToAsyncEnumerable();
 
             var resS = methodsS.GroupBy(m => m.Name, m => m.Name.ToUpper(), (k, g) => k + " - " + g.Count());
-            var resA = methodsA.GroupBy((m, ct) => new ValueTask<string>(m.Name), (m, ct) => new ValueTask<string>(m.Name.ToUpper()), async (k, g, ct) => k + " - " + await g.CountAsync(ct));
+            var resA = methodsA.GroupByAwaitWithCancellation((m, ct) => new ValueTask<string>(m.Name), (m, ct) => new ValueTask<string>(m.Name.ToUpper()), async (k, g, ct) => k + " - " + await g.CountAsync(ct));
 
             await Group_Result_AssertCore(resS, resA);
         }
@@ -498,10 +498,10 @@ namespace Tests
         [Fact]
         public void KeySelector_ElementSelector_ResultSelector_Async_Cancel_Comparer_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (int x, CancellationToken ct) => new ValueTask<int>(x), (k, g, ct) => new ValueTask<int>(0), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), (int x, CancellationToken ct) => new ValueTask<int>(x), (k, g, ct) => new ValueTask<int>(0), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, CancellationToken, ValueTask<int>>), (k, g, ct) => new ValueTask<int>(0), EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, CancellationToken, ValueTask<int>>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (int x, CancellationToken ct) => new ValueTask<int>(x), (k, g, ct) => new ValueTask<int>(0), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int, int>(Return42, default(Func<int, CancellationToken, ValueTask<int>>), (int x, CancellationToken ct) => new ValueTask<int>(x), (k, g, ct) => new ValueTask<int>(0), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, CancellationToken, ValueTask<int>>), (k, g, ct) => new ValueTask<int>(0), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupByAwaitWithCancellation<int, int, int, int>(default(IAsyncEnumerable<int>), (int x, CancellationToken ct) => new ValueTask<int>(x), (int x, CancellationToken ct) => new ValueTask<int>(x), default(Func<int, IAsyncEnumerable<int>, CancellationToken, ValueTask<int>>), EqualityComparer<int>.Default));
         }
 
         [Fact]
@@ -513,7 +513,7 @@ namespace Tests
             var eq = new StringPrefixEqualityComparer(1);
 
             var resS = methodsS.GroupBy(m => m.Name, m => m.Name.ToUpper(), (k, g) => k + " - " + g.Count(), eq);
-            var resA = methodsA.GroupBy((m, ct) => new ValueTask<string>(m.Name), (m, ct) => new ValueTask<string>(m.Name.ToUpper()), async (k, g, ct) => k + " - " + await g.CountAsync(ct), eq);
+            var resA = methodsA.GroupByAwaitWithCancellation((m, ct) => new ValueTask<string>(m.Name), (m, ct) => new ValueTask<string>(m.Name.ToUpper()), async (k, g, ct) => k + " - " + await g.CountAsync(ct), eq);
 
             await Group_Result_AssertCore(resS, resA);
         }

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/GroupBy.Generated.tt

@@ -24,6 +24,7 @@ foreach (var kind in new[] { "Sync", "Async", "Async_Cancel" })
 {
     string keySelectorType, elementSelectorType, resultSelectorType;
     string keySelectorFunc, elementSelectorFunc, resultSelectorFunc;
+    string suffix;
     bool isCancel = false;
 
     switch (kind)
@@ -33,18 +34,21 @@ foreach (var kind in new[] { "Sync", "Async", "Async_Cancel" })
             keySelectorFunc = elementSelectorFunc = "(int x) => x";
             resultSelectorType = "Func<int, IAsyncEnumerable<int>, int>";
             resultSelectorFunc = "(k, g) => 0";
+            suffix = "";
             break;
         case "Async":
             keySelectorType = elementSelectorType = "Func<int, ValueTask<int>>";
             keySelectorFunc = elementSelectorFunc = "(int x) => new ValueTask<int>(x)";
             resultSelectorType = "Func<int, IAsyncEnumerable<int>, ValueTask<int>>";
             resultSelectorFunc = "(k, g) => new ValueTask<int>(0)";
+            suffix = "Await";
             break;
         case "Async_Cancel":
             keySelectorType = elementSelectorType = "Func<int, CancellationToken, ValueTask<int>>";
             keySelectorFunc = elementSelectorFunc = "(int x, CancellationToken ct) => new ValueTask<int>(x)";
             resultSelectorType = "Func<int, IAsyncEnumerable<int>, CancellationToken, ValueTask<int>>";
             resultSelectorFunc = "(k, g, ct) => new ValueTask<int>(0)";
+            suffix = "AwaitWithCancellation";
             isCancel = true;
             break;
         default:
@@ -84,8 +88,8 @@ foreach (var kind in new[] { "Sync", "Async", "Async_Cancel" })
         [Fact]
         public void KeySelector_<#=kind#>_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(Return42, default(<#=keySelectorType#>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int>(Return42, default(<#=keySelectorType#>)));
         }
 
         [Fact]
@@ -95,7 +99,7 @@ foreach (var kind in new[] { "Sync", "Async", "Async_Cancel" })
             var methodsA = methodsS.ToAsyncEnumerable();
 
             var resS = methodsS.GroupBy(m => m.Name);
-            var resA = methodsA.GroupBy(<#=keySelector#>);
+            var resA = methodsA.GroupBy<#=suffix#>(<#=keySelector#>);
 
             await Groups_AssertCore(resS, resA);
         }
@@ -103,8 +107,8 @@ foreach (var kind in new[] { "Sync", "Async", "Async_Cancel" })
         [Fact]
         public void KeySelector_<#=kind#>_Comparer_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(Return42, default(<#=keySelectorType#>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int>(Return42, default(<#=keySelectorType#>), EqualityComparer<int>.Default));
         }
 
         [Fact]
@@ -116,7 +120,7 @@ foreach (var kind in new[] { "Sync", "Async", "Async_Cancel" })
             var eq = new StringPrefixEqualityComparer(1);
 
             var resS = methodsS.GroupBy(m => m.Name, eq);
-            var resA = methodsA.GroupBy(<#=keySelector#>, eq);
+            var resA = methodsA.GroupBy<#=suffix#>(<#=keySelector#>, eq);
 
             await Groups_AssertCore(resS, resA);
         }
@@ -124,9 +128,9 @@ foreach (var kind in new[] { "Sync", "Async", "Async_Cancel" })
         [Fact]
         public void KeySelector_ElementSelector_<#=kind#>_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=elementSelectorFunc#>));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default(<#=keySelectorType#>), <#=elementSelectorFunc#>));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, <#=keySelectorFunc#>, default(<#=elementSelectorType#>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=elementSelectorFunc#>));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int>(Return42, default(<#=keySelectorType#>), <#=elementSelectorFunc#>));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int>(Return42, <#=keySelectorFunc#>, default(<#=elementSelectorType#>)));
         }
 
         [Fact]
@@ -136,7 +140,7 @@ foreach (var kind in new[] { "Sync", "Async", "Async_Cancel" })
             var methodsA = methodsS.ToAsyncEnumerable();
 
             var resS = methodsS.GroupBy(m => m.Name, m => m.Name.ToUpper());
-            var resA = methodsA.GroupBy(<#=keySelector#>, <#=elementSelector#>);
+            var resA = methodsA.GroupBy<#=suffix#>(<#=keySelector#>, <#=elementSelector#>);
 
             await Groups_AssertCore(resS, resA);
         }
@@ -144,9 +148,9 @@ foreach (var kind in new[] { "Sync", "Async", "Async_Cancel" })
         [Fact]
         public void KeySelector_ElementSelector_<#=kind#>_Comparer_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=elementSelectorFunc#>, EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default(<#=keySelectorType#>), <#=elementSelectorFunc#>, EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, default(<#=elementSelectorType#>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=elementSelectorFunc#>, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int>(Return42, default(<#=keySelectorType#>), <#=elementSelectorFunc#>, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, default(<#=elementSelectorType#>), EqualityComparer<int>.Default));
         }
 
         [Fact]
@@ -158,7 +162,7 @@ foreach (var kind in new[] { "Sync", "Async", "Async_Cancel" })
             var eq = new StringPrefixEqualityComparer(1);
 
             var resS = methodsS.GroupBy(m => m.Name, m => m.Name.ToUpper(), eq);
-            var resA = methodsA.GroupBy(<#=keySelector#>, <#=elementSelector#>, eq);
+            var resA = methodsA.GroupBy<#=suffix#>(<#=keySelector#>, <#=elementSelector#>, eq);
 
             await Groups_AssertCore(resS, resA);
         }
@@ -166,9 +170,9 @@ foreach (var kind in new[] { "Sync", "Async", "Async_Cancel" })
         [Fact]
         public void KeySelector_ResultSelector_<#=kind#>_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=resultSelectorFunc#>));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default(<#=keySelectorType#>), <#=resultSelectorFunc#>));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, <#=keySelectorFunc#>, default(<#=resultSelectorType#>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=resultSelectorFunc#>));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int>(Return42, default(<#=keySelectorType#>), <#=resultSelectorFunc#>));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int>(Return42, <#=keySelectorFunc#>, default(<#=resultSelectorType#>)));
         }
 
         [Fact]
@@ -178,20 +182,7 @@ foreach (var kind in new[] { "Sync", "Async", "Async_Cancel" })
             var methodsA = methodsS.ToAsyncEnumerable();
 
             var resS = methodsS.GroupBy(m => m.Name, (k, g) => k + " - " + g.Count());
-<#
-if (kind == "Async")
-{
-#>
-            var resA = methodsA.GroupBy<System.Reflection.MethodInfo, string, string>(<#=keySelector#>, <#=resultSelector#>); // REVIEW: Ambiguity
-<#
-}
-else
-{
-#>
-            var resA = methodsA.GroupBy(<#=keySelector#>, <#=resultSelector#>);
-<#
-}
-#>
+            var resA = methodsA.GroupBy<#=suffix#>(<#=keySelector#>, <#=resultSelector#>);
 
             await Group_Result_AssertCore(resS, resA);
         }
@@ -199,9 +190,9 @@ else
         [Fact]
         public void KeySelector_ResultSelector_<#=kind#>_Comparer_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=resultSelectorFunc#>, EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(Return42, default(<#=keySelectorType#>), <#=resultSelectorFunc#>, EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, default(<#=resultSelectorType#>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=resultSelectorFunc#>, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int>(Return42, default(<#=keySelectorType#>), <#=resultSelectorFunc#>, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, default(<#=resultSelectorType#>), EqualityComparer<int>.Default));
         }
 
         [Fact]
@@ -213,7 +204,7 @@ else
             var eq = new StringPrefixEqualityComparer(1);
 
             var resS = methodsS.GroupBy(m => m.Name, (k, g) => k + " - " + g.Count(), eq);
-            var resA = methodsA.GroupBy(<#=keySelector#>, <#=resultSelector#>, eq);
+            var resA = methodsA.GroupBy<#=suffix#>(<#=keySelector#>, <#=resultSelector#>, eq);
 
             await Group_Result_AssertCore(resS, resA);
         }
@@ -221,10 +212,10 @@ else
         [Fact]
         public void KeySelector_ElementSelector_ResultSelector_<#=kind#>_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=elementSelectorFunc#>, <#=resultSelectorFunc#>));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, default(<#=keySelectorType#>), <#=elementSelectorFunc#>, <#=resultSelectorFunc#>));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, <#=keySelectorFunc#>, default(<#=elementSelectorType#>), <#=resultSelectorFunc#>));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, <#=keySelectorFunc#>, <#=elementSelectorFunc#>, default(<#=resultSelectorType#>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=elementSelectorFunc#>, <#=resultSelectorFunc#>));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int, int>(Return42, default(<#=keySelectorType#>), <#=elementSelectorFunc#>, <#=resultSelectorFunc#>));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int, int>(Return42, <#=keySelectorFunc#>, default(<#=elementSelectorType#>), <#=resultSelectorFunc#>));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int, int>(Return42, <#=keySelectorFunc#>, <#=elementSelectorFunc#>, default(<#=resultSelectorType#>)));
         }
 
         [Fact]
@@ -234,20 +225,7 @@ else
             var methodsA = methodsS.ToAsyncEnumerable();
 
             var resS = methodsS.GroupBy(m => m.Name, m => m.Name.ToUpper(), (k, g) => k + " - " + g.Count());
-<#
-if (kind == "Async")
-{
-#>
-            var resA = methodsA.GroupBy<System.Reflection.MethodInfo, string, string, string>(<#=keySelector#>, <#=elementSelector#>, <#=resultSelector#>); // REVIEW: Ambiguity
-<#
-}
-else
-{
-#>
-            var resA = methodsA.GroupBy(<#=keySelector#>, <#=elementSelector#>, <#=resultSelector#>);
-<#
-}
-#>
+            var resA = methodsA.GroupBy<#=suffix#>(<#=keySelector#>, <#=elementSelector#>, <#=resultSelector#>);
 
             await Group_Result_AssertCore(resS, resA);
         }
@@ -255,10 +233,10 @@ else
         [Fact]
         public void KeySelector_ElementSelector_ResultSelector_<#=kind#>_Comparer_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=elementSelectorFunc#>, <#=resultSelectorFunc#>, EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(Return42, default(<#=keySelectorType#>), <#=elementSelectorFunc#>, <#=resultSelectorFunc#>, EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, default(<#=elementSelectorType#>), <#=resultSelectorFunc#>, EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=elementSelectorFunc#>, default(<#=resultSelectorType#>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=elementSelectorFunc#>, <#=resultSelectorFunc#>, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int, int>(Return42, default(<#=keySelectorType#>), <#=elementSelectorFunc#>, <#=resultSelectorFunc#>, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, default(<#=elementSelectorType#>), <#=resultSelectorFunc#>, EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<#=suffix#><int, int, int, int>(default(IAsyncEnumerable<int>), <#=keySelectorFunc#>, <#=elementSelectorFunc#>, default(<#=resultSelectorType#>), EqualityComparer<int>.Default));
         }
 
         [Fact]
@@ -270,7 +248,7 @@ else
             var eq = new StringPrefixEqualityComparer(1);
 
             var resS = methodsS.GroupBy(m => m.Name, m => m.Name.ToUpper(), (k, g) => k + " - " + g.Count(), eq);
-            var resA = methodsA.GroupBy(<#=keySelector#>, <#=elementSelector#>, <#=resultSelector#>, eq);
+            var resA = methodsA.GroupBy<#=suffix#>(<#=keySelector#>, <#=elementSelector#>, <#=resultSelector#>, eq);
 
             await Group_Result_AssertCore(resS, resA);
         }

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/GroupBy.cs

@@ -214,7 +214,7 @@ namespace Tests
         public void GroupBy_KeySelector_Sync_Comparer_Null()
         {
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy<int, int>(default, x => x, EqualityComparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, default(Func<int, int>), EqualityComparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.GroupBy(Return42, default, EqualityComparer<int>.Default));
         }
 
         [Fact]

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Last.cs

@@ -23,17 +23,17 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAsync(Return42, default(Func<int, bool>)).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAsync<int>(default, x => true, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAsync(Return42, default(Func<int, bool>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAsync(Return42, default, CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAsync(Return42, default(Func<int, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAwaitAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAwaitAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAsync(Return42, default(Func<int, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAwaitAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAwaitAsync(Return42, default, CancellationToken.None).AsTask());
 
 #if !NO_DEEP_CANCELLATION
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastAwaitWithCancellationAsync(Return42, default, CancellationToken.None).AsTask());
 #endif
         }
 
@@ -173,159 +173,159 @@ namespace Tests
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicate_Empty()
+        public async Task LastAwaitAsync_Predicate_Empty()
         {
-            var res = AsyncEnumerable.Empty<int>().LastAsync(x => new ValueTask<bool>(true));
+            var res = AsyncEnumerable.Empty<int>().LastAwaitAsync(x => new ValueTask<bool>(true));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicate_Throw()
+        public async Task LastAwaitAsync_Predicate_Throw()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).LastAsync(x => new ValueTask<bool>(true));
+            var res = Throw<int>(ex).LastAwaitAsync(x => new ValueTask<bool>(true));
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicate_Single_None()
+        public async Task LastAwaitAsync_Predicate_Single_None()
         {
-            var res = Return42.LastAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = Return42.LastAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicate_Many_IList_None()
+        public async Task LastAwaitAsync_Predicate_Many_IList_None()
         {
-            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().LastAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().LastAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicate_Many_None()
+        public async Task LastAwaitAsync_Predicate_Many_None()
         {
-            var res = new[] { 40, 42, 44 }.Select(x => x).ToAsyncEnumerable().LastAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 40, 42, 44 }.Select(x => x).ToAsyncEnumerable().LastAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicate_Single_Pass()
+        public async Task LastAwaitAsync_Predicate_Single_Pass()
         {
-            var res = Return42.LastAsync(x => new ValueTask<bool>(x % 2 == 0));
+            var res = Return42.LastAwaitAsync(x => new ValueTask<bool>(x % 2 == 0));
             Assert.Equal(42, await res);
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicate_Many_IList_Pass1()
+        public async Task LastAwaitAsync_Predicate_Many_IList_Pass1()
         {
-            var res = new[] { 43, 44, 45 }.ToAsyncEnumerable().LastAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 43, 44, 45 }.ToAsyncEnumerable().LastAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicate_Many_IList_Pass2()
+        public async Task LastAwaitAsync_Predicate_Many_IList_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicate_Many_Pass1()
+        public async Task LastAwaitAsync_Predicate_Many_Pass1()
         {
-            var res = new[] { 43, 44, 45 }.Select(x => x).ToAsyncEnumerable().LastAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 43, 44, 45 }.Select(x => x).ToAsyncEnumerable().LastAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicate_Many_Pass2()
+        public async Task LastAwaitAsync_Predicate_Many_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.Select(x => x).ToAsyncEnumerable().LastAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 45, 90 }.Select(x => x).ToAsyncEnumerable().LastAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicate_AsyncPredicateThrows()
+        public async Task LastAwaitAsync_Predicate_AsyncPredicateThrows()
         {
-            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().LastAsync(x => new ValueTask<bool>(1 / x > 0));
+            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().LastAwaitAsync(x => new ValueTask<bool>(1 / x > 0));
             await AssertThrowsAsync<DivideByZeroException>(res.AsTask());
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task LastAsync_AsyncPredicateWithCancellation_Empty()
+        public async Task LastAwaitWithCancellationAsync_Predicate_Empty()
         {
-            var res = AsyncEnumerable.Empty<int>().LastAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
+            var res = AsyncEnumerable.Empty<int>().LastAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicateWithCancellation_Throw()
+        public async Task LastAwaitWithCancellationAsync_Predicate_Throw()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).LastAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
+            var res = Throw<int>(ex).LastAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicateWithCancellation_Single_None()
+        public async Task LastAwaitWithCancellationAsync_Predicate_Single_None()
         {
-            var res = Return42.LastAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = Return42.LastAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicateWithCancellation_Many_IList_None()
+        public async Task LastAwaitWithCancellationAsync_Predicate_Many_IList_None()
         {
-            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().LastAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().LastAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicateWithCancellation_Many_None()
+        public async Task LastAwaitWithCancellationAsync_Predicate_Many_None()
         {
-            var res = new[] { 40, 42, 44 }.Select((x, ct) => x).ToAsyncEnumerable().LastAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 40, 42, 44 }.Select((x, ct) => x).ToAsyncEnumerable().LastAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicateWithCancellation_Single_Pass()
+        public async Task LastAwaitWithCancellationAsync_Predicate_Single_Pass()
         {
-            var res = Return42.LastAsync((x, ct) => new ValueTask<bool>(x % 2 == 0), CancellationToken.None);
+            var res = Return42.LastAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 == 0), CancellationToken.None);
             Assert.Equal(42, await res);
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicateWithCancellation_Many_IList_Pass1()
+        public async Task LastAwaitWithCancellationAsync_Predicate_Many_IList_Pass1()
         {
-            var res = new[] { 43, 44, 45 }.ToAsyncEnumerable().LastAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 43, 44, 45 }.ToAsyncEnumerable().LastAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicateWithCancellation_Many_IList_Pass2()
+        public async Task LastAwaitWithCancellationAsync_Predicate_Many_IList_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicateWithCancellation_Many_Pass1()
+        public async Task LastAwaitWithCancellationAsync_Predicate_Many_Pass1()
         {
-            var res = new[] { 43, 44, 45 }.Select((x, ct) => x).ToAsyncEnumerable().LastAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 43, 44, 45 }.Select((x, ct) => x).ToAsyncEnumerable().LastAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicateWithCancellation_Many_Pass2()
+        public async Task LastAwaitWithCancellationAsync_Predicate_Many_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.Select((x, ct) => x).ToAsyncEnumerable().LastAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 42, 45, 90 }.Select((x, ct) => x).ToAsyncEnumerable().LastAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastAsync_AsyncPredicateWithCancellation_AsyncPredicateWithCancellationThrows()
+        public async Task LastAwaitWithCancellationAsync_Predicate_AsyncPredicateWithCancellationThrows()
         {
-            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().LastAsync((x, ct) => new ValueTask<bool>(1 / x > 0), CancellationToken.None);
+            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().LastAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(1 / x > 0), CancellationToken.None);
             await AssertThrowsAsync<DivideByZeroException>(res.AsTask());
         }
 #endif

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/LastOrDefault.cs

@@ -23,17 +23,17 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAsync(Return42, default(Func<int, bool>)).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAsync<int>(default, x => true, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAsync(Return42, default(Func<int, bool>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAsync(Return42, default, CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAsync(Return42, default(Func<int, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAwaitAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAwaitAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAsync(Return42, default(Func<int, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAwaitAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAwaitAsync(Return42, default, CancellationToken.None).AsTask());
 
 #if !NO_DEEP_CANCELLATION
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LastOrDefaultAwaitWithCancellationAsync(Return42, default, CancellationToken.None).AsTask());
 #endif
         }
 
@@ -173,159 +173,159 @@ namespace Tests
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicate_Empty()
+        public async Task LastOrDefaultAwaitAsync_Predicate_Empty()
         {
-            var res = AsyncEnumerable.Empty<int>().LastOrDefaultAsync(x => new ValueTask<bool>(true));
+            var res = AsyncEnumerable.Empty<int>().LastOrDefaultAwaitAsync(x => new ValueTask<bool>(true));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicate_Throw()
+        public async Task LastOrDefaultAwaitAsync_Predicate_Throw()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).LastOrDefaultAsync(x => new ValueTask<bool>(true));
+            var res = Throw<int>(ex).LastOrDefaultAwaitAsync(x => new ValueTask<bool>(true));
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicate_Single_None()
+        public async Task LastOrDefaultAwaitAsync_Predicate_Single_None()
         {
-            var res = Return42.LastOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = Return42.LastOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicate_Many_IList_None()
+        public async Task LastOrDefaultAwaitAsync_Predicate_Many_IList_None()
         {
-            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().LastOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().LastOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicate_Many_None()
+        public async Task LastOrDefaultAwaitAsync_Predicate_Many_None()
         {
-            var res = new[] { 40, 42, 44 }.Select(x => x).ToAsyncEnumerable().LastOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 40, 42, 44 }.Select(x => x).ToAsyncEnumerable().LastOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicate_Single_Pass()
+        public async Task LastOrDefaultAwaitAsync_Predicate_Single_Pass()
         {
-            var res = Return42.LastOrDefaultAsync(x => new ValueTask<bool>(x % 2 == 0));
+            var res = Return42.LastOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 == 0));
             Assert.Equal(42, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicate_Many_IList_Pass1()
+        public async Task LastOrDefaultAwaitAsync_Predicate_Many_IList_Pass1()
         {
-            var res = new[] { 43, 44, 45 }.ToAsyncEnumerable().LastOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 43, 44, 45 }.ToAsyncEnumerable().LastOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicate_Many_IList_Pass2()
+        public async Task LastOrDefaultAwaitAsync_Predicate_Many_IList_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicate_Many_Pass1()
+        public async Task LastOrDefaultAwaitAsync_Predicate_Many_Pass1()
         {
-            var res = new[] { 43, 44, 45 }.Select(x => x).ToAsyncEnumerable().LastOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 43, 44, 45 }.Select(x => x).ToAsyncEnumerable().LastOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicate_Many_Pass2()
+        public async Task LastOrDefaultAwaitAsync_Predicate_Many_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.Select(x => x).ToAsyncEnumerable().LastOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 45, 90 }.Select(x => x).ToAsyncEnumerable().LastOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicate_AsyncPredicateThrows()
+        public async Task LastOrDefaultAwaitAsync_Predicate_AsyncPredicateThrows()
         {
-            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().LastOrDefaultAsync(x => new ValueTask<bool>(1 / x > 0));
+            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().LastOrDefaultAwaitAsync(x => new ValueTask<bool>(1 / x > 0));
             await AssertThrowsAsync<DivideByZeroException>(res.AsTask());
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicateWithCancellation_Empty()
+        public async Task LastOrDefaultAwaitWithCancellationAsync_Predicate_Empty()
         {
-            var res = AsyncEnumerable.Empty<int>().LastOrDefaultAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
+            var res = AsyncEnumerable.Empty<int>().LastOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicateWithCancellation_Throw()
+        public async Task LastOrDefaultAwaitWithCancellationAsync_Predicate_Throw()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).LastOrDefaultAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
+            var res = Throw<int>(ex).LastOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true), CancellationToken.None);
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicateWithCancellation_Single_None()
+        public async Task LastOrDefaultAwaitWithCancellationAsync_Predicate_Single_None()
         {
-            var res = Return42.LastOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = Return42.LastOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicateWithCancellation_Many_IList_None()
+        public async Task LastOrDefaultAwaitWithCancellationAsync_Predicate_Many_IList_None()
         {
-            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().LastOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 40, 42, 44 }.ToAsyncEnumerable().LastOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicateWithCancellation_Many_None()
+        public async Task LastOrDefaultAwaitWithCancellationAsync_Predicate_Many_None()
         {
-            var res = new[] { 40, 42, 44 }.Select((x, ct) => x).ToAsyncEnumerable().LastOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 40, 42, 44 }.Select((x, ct) => x).ToAsyncEnumerable().LastOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicateWithCancellation_Single_Pass()
+        public async Task LastOrDefaultAwaitWithCancellationAsync_Predicate_Single_Pass()
         {
-            var res = Return42.LastOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 == 0), CancellationToken.None);
+            var res = Return42.LastOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 == 0), CancellationToken.None);
             Assert.Equal(42, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicateWithCancellation_Many_IList_Pass1()
+        public async Task LastOrDefaultAwaitWithCancellationAsync_Predicate_Many_IList_Pass1()
         {
-            var res = new[] { 43, 44, 45 }.ToAsyncEnumerable().LastOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 43, 44, 45 }.ToAsyncEnumerable().LastOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicateWithCancellation_Many_IList_Pass2()
+        public async Task LastOrDefaultAwaitWithCancellationAsync_Predicate_Many_IList_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().LastOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicateWithCancellation_Many_Pass1()
+        public async Task LastOrDefaultAwaitWithCancellationAsync_Predicate_Many_Pass1()
         {
-            var res = new[] { 43, 44, 45 }.Select((x, ct) => x).ToAsyncEnumerable().LastOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 43, 44, 45 }.Select((x, ct) => x).ToAsyncEnumerable().LastOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicateWithCancellation_Many_Pass2()
+        public async Task LastOrDefaultAwaitWithCancellationAsync_Predicate_Many_Pass2()
         {
-            var res = new[] { 42, 45, 90 }.Select((x, ct) => x).ToAsyncEnumerable().LastOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
+            var res = new[] { 42, 45, 90 }.Select((x, ct) => x).ToAsyncEnumerable().LastOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0), CancellationToken.None);
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task LastOrDefaultAsync_AsyncPredicateWithCancellation_AsyncPredicateWithCancellationThrows()
+        public async Task LastOrDefaultAwaitWithCancellationAsync_Predicate_AsyncPredicateWithCancellationThrows()
         {
-            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().LastOrDefaultAsync((x, ct) => new ValueTask<bool>(1 / x > 0), CancellationToken.None);
+            var res = new[] { 0, 1, 2 }.ToAsyncEnumerable().LastOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(1 / x > 0), CancellationToken.None);
             await AssertThrowsAsync<DivideByZeroException>(res.AsTask());
         }
 #endif

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/LongCount.cs

@@ -40,7 +40,7 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAsync(Return42, default(Func<int, bool>)).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAsync<int>(default, x => true, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAsync(Return42, default(Func<int, bool>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
@@ -66,68 +66,68 @@ namespace Tests
         }
 
         [Fact]
-        public async Task LongCountAsync_AsyncPredicate_Null()
+        public async Task LongCountAwaitAsync_Predicate_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAsync(Return42, default(Func<int, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAwaitAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAwaitAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAsync(Return42, default(Func<int, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAwaitAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAwaitAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task LongCountAsync_AsyncPredicate()
+        public async Task LongCountAwaitAsync_Predicate()
         {
-            Assert.Equal(0, await new int[0].ToAsyncEnumerable().LongCountAsync(x => new ValueTask<bool>(x < 3)));
-            Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCountAsync(x => new ValueTask<bool>(x < 3)));
+            Assert.Equal(0, await new int[0].ToAsyncEnumerable().LongCountAwaitAsync(x => new ValueTask<bool>(x < 3)));
+            Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCountAwaitAsync(x => new ValueTask<bool>(x < 3)));
         }
 
         [Fact]
-        public async Task LongCountAsync_AsyncPredicate_Throws_Predicate()
+        public async Task LongCountAwaitAsync_Predicate_Throws_Predicate()
         {
             var ex = new Exception("Bang!");
-            var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCountAsync(new Func<int, ValueTask<bool>>(x => { throw ex; }));
+            var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCountAwaitAsync(new Func<int, ValueTask<bool>>(x => { throw ex; }));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task LongCountAsync_AsyncPredicate_Throws_Source()
+        public async Task LongCountAwaitAsync_Predicate_Throws_Source()
         {
             var ex = new Exception("Bang!");
-            await AssertThrowsAsync(Throw<int>(ex).LongCountAsync(x => new ValueTask<bool>(x < 3)), ex);
+            await AssertThrowsAsync(Throw<int>(ex).LongCountAwaitAsync(x => new ValueTask<bool>(x < 3)), ex);
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task LongCountAsync_AsyncPredicateCancel_Null()
+        public async Task LongCountAwaitWithCancellationAsync_Predicate_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAsync<int>(default, (x, ct) => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAwaitWithCancellationAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.LongCountAwaitWithCancellationAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task LongCountAsync_AsyncPredicateCancel()
+        public async Task LongCountAwaitWithCancellationAsync_Predicate()
         {
-            Assert.Equal(0, await new int[0].ToAsyncEnumerable().LongCountAsync((x, ct) => new ValueTask<bool>(x < 3)));
-            Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCountAsync((x, ct) => new ValueTask<bool>(x < 3)));
+            Assert.Equal(0, await new int[0].ToAsyncEnumerable().LongCountAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x < 3)));
+            Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCountAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x < 3)));
         }
 
         [Fact]
-        public async Task LongCountAsync_AsyncPredicateCancel_Throws_Predicate()
+        public async Task LongCountAwaitWithCancellationAsync_Predicate_Throws_Predicate()
         {
             var ex = new Exception("Bang!");
-            var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCountAsync(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
+            var ys = new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCountAwaitWithCancellationAsync(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
             await AssertThrowsAsync(ys, ex);
         }
 
         [Fact]
-        public async Task LongCountAsync_AsyncPredicateCancel_Throws_Source()
+        public async Task LongCountAwaitWithCancellationAsync_Predicate_Throws_Source()
         {
             var ex = new Exception("Bang!");
-            await AssertThrowsAsync(Throw<int>(ex).LongCountAsync((x, ct) => new ValueTask<bool>(x < 3)), ex);
+            await AssertThrowsAsync(Throw<int>(ex).LongCountAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x < 3)), ex);
         }
 #endif
     }

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Max.cs

@@ -79,7 +79,7 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None).AsTask());
@@ -92,76 +92,76 @@ namespace Tests
 
             // Max<T>(IAE<T>, Func<T, VT<P>>)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x)).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x)).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>)).AsTask());
 
             // Max<T>(IAE<T>, Func<T, VT<P>>, CT)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>), CancellationToken.None).AsTask());
 
 #if !NO_DEEP_CANCELLATION
             // Max<T>(IAE<T>, Func<T, CT, VT<P>>, CT)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<int>), (x, ct) => new ValueTask<int>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<int?>), (x, ct) => new ValueTask<int?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<long>), (x, ct) => new ValueTask<long>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<long?>), (x, ct) => new ValueTask<long?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<double>), (x, ct) => new ValueTask<double>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<double?>), (x, ct) => new ValueTask<double?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<float>), (x, ct) => new ValueTask<float>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<float?>), (x, ct) => new ValueTask<float?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<decimal>), (x, ct) => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<decimal?>), (x, ct) => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<int>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<int?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(default(IAsyncEnumerable<int>), (x, ct) => new ValueTask<int>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(default(IAsyncEnumerable<int?>), (x, ct) => new ValueTask<int?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(default(IAsyncEnumerable<long>), (x, ct) => new ValueTask<long>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(default(IAsyncEnumerable<long?>), (x, ct) => new ValueTask<long?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(default(IAsyncEnumerable<double>), (x, ct) => new ValueTask<double>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(default(IAsyncEnumerable<double?>), (x, ct) => new ValueTask<double?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(default(IAsyncEnumerable<float>), (x, ct) => new ValueTask<float>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(default(IAsyncEnumerable<float?>), (x, ct) => new ValueTask<float?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(default(IAsyncEnumerable<decimal>), (x, ct) => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(default(IAsyncEnumerable<decimal?>), (x, ct) => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<int?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal?>>), CancellationToken.None).AsTask());
 #endif
 
             // Max<T>(IAE<T>)
@@ -184,19 +184,19 @@ namespace Tests
 
             // Max<T>(IAE<T>, Func<T, VT<R>>)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<DateTime>), x => new ValueTask<DateTime>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<DateTime>), x => new ValueTask<DateTime>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, ValueTask<bool>>)).AsTask());
 
             // Max<T>(IAE<T>, Func<T, VT<R>>, CT)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<DateTime>), x => new ValueTask<DateTime>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(default(IAsyncEnumerable<DateTime>), x => new ValueTask<DateTime>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitAsync(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, ValueTask<bool>>), CancellationToken.None).AsTask());
 
 #if !NO_DEEP_CANCELLATION
             // Max<T>(IAE<T>, Func<T, CT, VT<R>>, CT)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(default(IAsyncEnumerable<DateTime>), (x, ct) => new ValueTask<DateTime>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAsync(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(default(IAsyncEnumerable<DateTime>), (x, ct) => new ValueTask<DateTime>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MaxAwaitWithCancellationAsync(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
 #endif
         }
 
@@ -207,9 +207,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
-            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<int>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitAsync(x => new ValueTask<int>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<int>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<int>(x)));
 #endif
         }
 
@@ -220,9 +220,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
-            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<int?>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitAsync(x => new ValueTask<int?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<int?>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<int?>(x)));
 #endif
         }
 
@@ -233,9 +233,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
-            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<long>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitAsync(x => new ValueTask<long>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<long>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<long>(x)));
 #endif
         }
 
@@ -246,9 +246,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
-            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<long?>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitAsync(x => new ValueTask<long?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<long?>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<long?>(x)));
 #endif
         }
 
@@ -259,9 +259,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
-            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<double>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitAsync(x => new ValueTask<double>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<double>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<double>(x)));
 #endif
         }
 
@@ -272,9 +272,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
-            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<double?>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitAsync(x => new ValueTask<double?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<double?>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<double?>(x)));
 #endif
         }
 
@@ -285,9 +285,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
-            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<float>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitAsync(x => new ValueTask<float>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<float>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<float>(x)));
 #endif
         }
 
@@ -298,9 +298,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
-            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<float?>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitAsync(x => new ValueTask<float?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<float?>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<float?>(x)));
 #endif
         }
 
@@ -311,9 +311,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
-            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<decimal>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitAsync(x => new ValueTask<decimal>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<decimal>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<decimal>(x)));
 #endif
         }
 
@@ -324,9 +324,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
-            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<decimal?>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitAsync(x => new ValueTask<decimal?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<decimal?>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<decimal?>(x)));
 #endif
         }
 
@@ -337,9 +337,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
-            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<DateTime>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitAsync(x => new ValueTask<DateTime>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<DateTime>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<DateTime>(x)));
 #endif
         }
 
@@ -350,9 +350,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
-            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<string>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitAsync(x => new ValueTask<string>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<string>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<string>(x)));
 #endif
         }
 
@@ -362,9 +362,9 @@ namespace Tests
             var xs = new DateTimeOffset[0].ToAsyncEnumerable();
             await AssertThrowsAsync<InvalidOperationException>(xs.MaxAsync().AsTask());
             await AssertThrowsAsync<InvalidOperationException>(xs.MaxAsync(x => x).AsTask());
-            await AssertThrowsAsync<InvalidOperationException>(xs.MaxAsync(x => new ValueTask<DateTimeOffset>(x)).AsTask());
+            await AssertThrowsAsync<InvalidOperationException>(xs.MaxAwaitAsync(x => new ValueTask<DateTimeOffset>(x)).AsTask());
 #if !NO_DEEP_CANCELLATION
-            await AssertThrowsAsync<InvalidOperationException>(xs.MaxAsync((x, ct) => new ValueTask<DateTimeOffset>(x)).AsTask());
+            await AssertThrowsAsync<InvalidOperationException>(xs.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<DateTimeOffset>(x)).AsTask());
 #endif
         }
 
@@ -374,9 +374,9 @@ namespace Tests
             var xs = new string[0].ToAsyncEnumerable();
             Assert.Null(await xs.MaxAsync());
             Assert.Null(await xs.MaxAsync(x => x));
-            Assert.Null(await xs.MaxAsync(x => new ValueTask<string>(x)));
+            Assert.Null(await xs.MaxAwaitAsync(x => new ValueTask<string>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Null(await xs.MaxAsync((x, ct) => new ValueTask<string>(x)));
+            Assert.Null(await xs.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<string>(x)));
 #endif
         }
 
@@ -386,9 +386,9 @@ namespace Tests
             var xs = new DateTimeOffset?[0].ToAsyncEnumerable();
             Assert.Null(await xs.MaxAsync());
             Assert.Null(await xs.MaxAsync(x => x));
-            Assert.Null(await xs.MaxAsync(x => new ValueTask<DateTimeOffset?>(x)));
+            Assert.Null(await xs.MaxAwaitAsync(x => new ValueTask<DateTimeOffset?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Null(await xs.MaxAsync((x, ct) => new ValueTask<DateTimeOffset?>(x)));
+            Assert.Null(await xs.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<DateTimeOffset?>(x)));
 #endif
         }
 
@@ -399,9 +399,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Max(), await ys.MaxAsync());
             Assert.Equal(xs.Max(), await ys.MaxAsync(x => x));
-            Assert.Equal(xs.Max(), await ys.MaxAsync(x => new ValueTask<DateTimeOffset?>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitAsync(x => new ValueTask<DateTimeOffset?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Max(), await ys.MaxAsync((x, ct) => new ValueTask<DateTimeOffset?>(x)));
+            Assert.Equal(xs.Max(), await ys.MaxAwaitWithCancellationAsync((x, ct) => new ValueTask<DateTimeOffset?>(x)));
 #endif
         }
     }

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Min.cs

@@ -79,7 +79,7 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None).AsTask());
@@ -92,76 +92,76 @@ namespace Tests
 
             // Min<T>(IAE<T>, Func<T, VT<P>>)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x)).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x)).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>)).AsTask());
 
             // Min<T>(IAE<T>, Func<T, VT<P>>, CT)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>), CancellationToken.None).AsTask());
 
 #if !NO_DEEP_CANCELLATION
             // Min<T>(IAE<T>, Func<T, CT, VT<P>>, CT)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<int>), (x, ct) => new ValueTask<int>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<int?>), (x, ct) => new ValueTask<int?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<long>), (x, ct) => new ValueTask<long>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<long?>), (x, ct) => new ValueTask<long?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<double>), (x, ct) => new ValueTask<double>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<double?>), (x, ct) => new ValueTask<double?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<float>), (x, ct) => new ValueTask<float>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<float?>), (x, ct) => new ValueTask<float?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<decimal>), (x, ct) => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<decimal?>), (x, ct) => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
-
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<int>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<int?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(default(IAsyncEnumerable<int>), (x, ct) => new ValueTask<int>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(default(IAsyncEnumerable<int?>), (x, ct) => new ValueTask<int?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(default(IAsyncEnumerable<long>), (x, ct) => new ValueTask<long>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(default(IAsyncEnumerable<long?>), (x, ct) => new ValueTask<long?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(default(IAsyncEnumerable<double>), (x, ct) => new ValueTask<double>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(default(IAsyncEnumerable<double?>), (x, ct) => new ValueTask<double?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(default(IAsyncEnumerable<float>), (x, ct) => new ValueTask<float>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(default(IAsyncEnumerable<float?>), (x, ct) => new ValueTask<float?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(default(IAsyncEnumerable<decimal>), (x, ct) => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(default(IAsyncEnumerable<decimal?>), (x, ct) => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
+
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<int?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal?>>), CancellationToken.None).AsTask());
 #endif
 
             // Min<T>(IAE<T>)
@@ -184,19 +184,19 @@ namespace Tests
 
             // Min<T>(IAE<T>, Func<T, VT<R>>)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<DateTime>), x => new ValueTask<DateTime>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<DateTime>), x => new ValueTask<DateTime>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, ValueTask<bool>>)).AsTask());
 
             // Min<T>(IAE<T>, Func<T, VT<R>>, CT)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<DateTime>), x => new ValueTask<DateTime>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(default(IAsyncEnumerable<DateTime>), x => new ValueTask<DateTime>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitAsync(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, ValueTask<bool>>), CancellationToken.None).AsTask());
 
 #if !NO_DEEP_CANCELLATION
             // Min<T>(IAE<T>, Func<T, CT, VT<R>>, CT)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(default(IAsyncEnumerable<DateTime>), (x, ct) => new ValueTask<DateTime>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAsync(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(default(IAsyncEnumerable<DateTime>), (x, ct) => new ValueTask<DateTime>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.MinAwaitWithCancellationAsync(AsyncEnumerable.Empty<DateTime>(), default(Func<DateTime, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
 #endif
         }
 
@@ -207,9 +207,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
-            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<int>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitAsync(x => new ValueTask<int>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<int>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<int>(x)));
 #endif
         }
 
@@ -220,9 +220,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
-            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<int?>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitAsync(x => new ValueTask<int?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<int?>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<int?>(x)));
 #endif
         }
 
@@ -233,9 +233,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
-            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<long>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitAsync(x => new ValueTask<long>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<long>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<long>(x)));
 #endif
         }
 
@@ -246,9 +246,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
-            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<long?>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitAsync(x => new ValueTask<long?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<long?>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<long?>(x)));
 #endif
         }
 
@@ -259,9 +259,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
-            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<double>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitAsync(x => new ValueTask<double>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<double>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<double>(x)));
 #endif
         }
 
@@ -272,9 +272,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
-            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<double?>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitAsync(x => new ValueTask<double?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<double?>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<double?>(x)));
 #endif
         }
 
@@ -285,9 +285,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
-            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<float>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitAsync(x => new ValueTask<float>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<float>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<float>(x)));
 #endif
         }
 
@@ -298,9 +298,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
-            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<float?>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitAsync(x => new ValueTask<float?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<float?>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<float?>(x)));
 #endif
         }
 
@@ -311,9 +311,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
-            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<decimal>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitAsync(x => new ValueTask<decimal>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<decimal>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<decimal>(x)));
 #endif
         }
 
@@ -324,9 +324,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
-            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<decimal?>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitAsync(x => new ValueTask<decimal?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<decimal?>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<decimal?>(x)));
 #endif
         }
 
@@ -337,9 +337,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
-            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<DateTime>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitAsync(x => new ValueTask<DateTime>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<DateTime>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<DateTime>(x)));
 #endif
         }
 
@@ -350,9 +350,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
-            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<string>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitAsync(x => new ValueTask<string>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<string>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<string>(x)));
 #endif
         }
 
@@ -362,9 +362,9 @@ namespace Tests
             var xs = new DateTimeOffset[0].ToAsyncEnumerable();
             await AssertThrowsAsync<InvalidOperationException>(xs.MinAsync().AsTask());
             await AssertThrowsAsync<InvalidOperationException>(xs.MinAsync(x => x).AsTask());
-            await AssertThrowsAsync<InvalidOperationException>(xs.MinAsync(x => new ValueTask<DateTimeOffset>(x)).AsTask());
+            await AssertThrowsAsync<InvalidOperationException>(xs.MinAwaitAsync(x => new ValueTask<DateTimeOffset>(x)).AsTask());
 #if !NO_DEEP_CANCELLATION
-            await AssertThrowsAsync<InvalidOperationException>(xs.MinAsync((x, ct) => new ValueTask<DateTimeOffset>(x)).AsTask());
+            await AssertThrowsAsync<InvalidOperationException>(xs.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<DateTimeOffset>(x)).AsTask());
 #endif
         }
 
@@ -374,9 +374,9 @@ namespace Tests
             var xs = new string[0].ToAsyncEnumerable();
             Assert.Null(await xs.MinAsync());
             Assert.Null(await xs.MinAsync(x => x));
-            Assert.Null(await xs.MinAsync(x => new ValueTask<string>(x)));
+            Assert.Null(await xs.MinAwaitAsync(x => new ValueTask<string>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Null(await xs.MinAsync((x, ct) => new ValueTask<string>(x)));
+            Assert.Null(await xs.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<string>(x)));
 #endif
         }
 
@@ -386,9 +386,9 @@ namespace Tests
             var xs = new DateTimeOffset?[0].ToAsyncEnumerable();
             Assert.Null(await xs.MinAsync());
             Assert.Null(await xs.MinAsync(x => x));
-            Assert.Null(await xs.MinAsync(x => new ValueTask<DateTimeOffset?>(x)));
+            Assert.Null(await xs.MinAwaitAsync(x => new ValueTask<DateTimeOffset?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Null(await xs.MinAsync((x, ct) => new ValueTask<DateTimeOffset?>(x)));
+            Assert.Null(await xs.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<DateTimeOffset?>(x)));
 #endif
         }
 
@@ -399,9 +399,9 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Min(), await ys.MinAsync());
             Assert.Equal(xs.Min(), await ys.MinAsync(x => x));
-            Assert.Equal(xs.Min(), await ys.MinAsync(x => new ValueTask<DateTimeOffset?>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitAsync(x => new ValueTask<DateTimeOffset?>(x)));
 #if !NO_DEEP_CANCELLATION
-            Assert.Equal(xs.Min(), await ys.MinAsync((x, ct) => new ValueTask<DateTimeOffset?>(x)));
+            Assert.Equal(xs.Min(), await ys.MinAwaitWithCancellationAsync((x, ct) => new ValueTask<DateTimeOffset?>(x)));
 #endif
         }
     }

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/MinMax.Generated.tt

@@ -54,54 +54,54 @@ foreach (var op in new[] { "Min", "Max" })
         var cs = toCSharp(t);
 #>
         [Fact]
-        public async Task <#=op#>_Empty_<#=t.Name#>()
+        public async Task <#=op#>Async_Empty_<#=t.Name#>()
         {
             await AssertThrowsAsync<InvalidOperationException>(new <#=cs#>[0].ToAsyncEnumerable().<#=op#>Async(CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task <#=op#>_Selector_Empty_<#=t.Name#>()
+        public async Task <#=op#>Async_Selector_Empty_<#=t.Name#>()
         {
             await AssertThrowsAsync<InvalidOperationException>(new object[0].ToAsyncEnumerable().<#=op#>Async(_ => default(<#=cs#>), CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task <#=op#>_AsyncSelector_Empty_<#=t.Name#>()
+        public async Task <#=op#>AwaitAsync_Selector_Empty_<#=t.Name#>()
         {
-            await AssertThrowsAsync<InvalidOperationException>(new object[0].ToAsyncEnumerable().<#=op#>Async(_ => default(ValueTask<<#=cs#>>), CancellationToken.None).AsTask());
+            await AssertThrowsAsync<InvalidOperationException>(new object[0].ToAsyncEnumerable().<#=op#>AwaitAsync(_ => default(ValueTask<<#=cs#>>), CancellationToken.None).AsTask());
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task <#=op#>_AsyncSelectorWithCancellation_Empty_<#=t.Name#>()
+        public async Task <#=op#>AwaitWithCancellationAsync_Selector_Empty_<#=t.Name#>()
         {
-            await AssertThrowsAsync<InvalidOperationException>(new object[0].ToAsyncEnumerable().<#=op#>Async((x, ct) => default(ValueTask<<#=cs#>>), CancellationToken.None).AsTask());
+            await AssertThrowsAsync<InvalidOperationException>(new object[0].ToAsyncEnumerable().<#=op#>AwaitWithCancellationAsync((x, ct) => default(ValueTask<<#=cs#>>), CancellationToken.None).AsTask());
         }
 #endif
 
         [Fact]
-        public async Task <#=op#>_Empty_Nullable_<#=t.Name#>()
+        public async Task <#=op#>Async_Empty_Nullable_<#=t.Name#>()
         {
             Assert.Null(await new <#=cs#>?[0].ToAsyncEnumerable().<#=op#>Async(CancellationToken.None));
         }
 
         [Fact]
-        public async Task <#=op#>_Selector_Empty_Nullable_<#=t.Name#>()
+        public async Task <#=op#>Async_Selector_Empty_Nullable_<#=t.Name#>()
         {
             Assert.Null(await new object[0].ToAsyncEnumerable().<#=op#>Async(_ => default(<#=cs#>?), CancellationToken.None));
         }
 
         [Fact]
-        public async Task <#=op#>_AsyncSelector_Empty_Nullable_<#=t.Name#>()
+        public async Task <#=op#>AwaitAsync_Selector_Empty_Nullable_<#=t.Name#>()
         {
-            Assert.Null(await new object[0].ToAsyncEnumerable().<#=op#>Async(_ => default(ValueTask<<#=cs#>?>), CancellationToken.None));
+            Assert.Null(await new object[0].ToAsyncEnumerable().<#=op#>AwaitAsync(_ => default(ValueTask<<#=cs#>?>), CancellationToken.None));
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task <#=op#>_AsyncSelectorWithCancellation_Empty_Nullable_<#=t.Name#>()
+        public async Task <#=op#>AwaitWithCancellationAsync_Selector_Empty_Nullable_<#=t.Name#>()
         {
-            Assert.Null(await new object[0].ToAsyncEnumerable().<#=op#>Async((x, ct) => default(ValueTask<<#=cs#>?>), CancellationToken.None));
+            Assert.Null(await new object[0].ToAsyncEnumerable().<#=op#>AwaitWithCancellationAsync((x, ct) => default(ValueTask<<#=cs#>?>), CancellationToken.None));
         }
 #endif
 
@@ -112,7 +112,7 @@ foreach (var op in new[] { "Min", "Max" })
             var valuesWithNull = string.Join(", ", getRandom(n * 42, n, -100, 100).Select((x, i) => i % 2 == 0 ? x.ToString() : "null"));
 #>
         [Fact]
-        public async Task <#=op#>_<#=t.Name#>_<#=n#>()
+        public async Task <#=op#>Async_<#=t.Name#>_<#=n#>()
         {
             var input = new <#=cs#>[] { <#=values#> }.AsEnumerable();
 
@@ -127,7 +127,7 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_Selector_<#=t.Name#>_<#=n#>()
+        public async Task <#=op#>Async_Selector_<#=t.Name#>_<#=n#>()
         {
             var input = new <#=cs#>[] { <#=values#> }.AsEnumerable();
 
@@ -142,14 +142,14 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_AsyncSelector_<#=t.Name#>_<#=n#>()
+        public async Task <#=op#>AwaitAsync_Selector_<#=t.Name#>_<#=n#>()
         {
             var input = new <#=cs#>[] { <#=values#> }.AsEnumerable();
 
             for (var i = 0; i < <#=ShuffleCount#>; i++)
             {
                 var expected = input.<#=op#>();
-                var actual = await input.ToAsyncEnumerable().<#=op#>Async(x => new ValueTask<<#=cs#>>(x), CancellationToken.None);
+                var actual = await input.ToAsyncEnumerable().<#=op#>AwaitAsync(x => new ValueTask<<#=cs#>>(x), CancellationToken.None);
                 Assert.Equal(expected, actual);
 
                 input = Shuffle(input);
@@ -158,14 +158,14 @@ foreach (var op in new[] { "Min", "Max" })
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task <#=op#>_AsyncSelectorWithCancellation_<#=t.Name#>_<#=n#>()
+        public async Task <#=op#>AwaitWithCancellationAsync_Selector_<#=t.Name#>_<#=n#>()
         {
             var input = new <#=cs#>[] { <#=values#> }.AsEnumerable();
 
             for (var i = 0; i < <#=ShuffleCount#>; i++)
             {
                 var expected = input.<#=op#>();
-                var actual = await input.ToAsyncEnumerable().<#=op#>Async((x, ct) => new ValueTask<<#=cs#>>(x), CancellationToken.None);
+                var actual = await input.ToAsyncEnumerable().<#=op#>AwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>>(x), CancellationToken.None);
                 Assert.Equal(expected, actual);
 
                 input = Shuffle(input);
@@ -174,7 +174,7 @@ foreach (var op in new[] { "Min", "Max" })
 #endif
 
         [Fact]
-        public async Task <#=op#>_<#=t.Name#>_Nullable_<#=n#>_NoNull()
+        public async Task <#=op#>Async_<#=t.Name#>_Nullable_<#=n#>_NoNull()
         {
             var input = new <#=cs#>?[] { <#=values#> }.AsEnumerable();
 
@@ -189,7 +189,7 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_Selector_<#=t.Name#>_Nullable_<#=n#>_NoNull()
+        public async Task <#=op#>Async_Selector_<#=t.Name#>_Nullable_<#=n#>_NoNull()
         {
             var input = new <#=cs#>?[] { <#=values#> }.AsEnumerable();
 
@@ -204,14 +204,14 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_AsyncSelector_<#=t.Name#>_Nullable_<#=n#>_NoNull()
+        public async Task <#=op#>AwaitAsync_Selector_<#=t.Name#>_Nullable_<#=n#>_NoNull()
         {
             var input = new <#=cs#>?[] { <#=values#> }.AsEnumerable();
 
             for (var i = 0; i < <#=ShuffleCount#>; i++)
             {
                 var expected = input.<#=op#>();
-                var actual = await input.ToAsyncEnumerable().<#=op#>Async(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+                var actual = await input.ToAsyncEnumerable().<#=op#>AwaitAsync(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
                 Assert.Equal(expected, actual);
 
                 input = Shuffle(input);
@@ -220,14 +220,14 @@ foreach (var op in new[] { "Min", "Max" })
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task <#=op#>_AsyncSelectorWithCancellation_<#=t.Name#>_Nullable_<#=n#>_NoNull()
+        public async Task <#=op#>AwaitWithCancellationAsync_Selector_<#=t.Name#>_Nullable_<#=n#>_NoNull()
         {
             var input = new <#=cs#>?[] { <#=values#> }.AsEnumerable();
 
             for (var i = 0; i < <#=ShuffleCount#>; i++)
             {
                 var expected = input.<#=op#>();
-                var actual = await input.ToAsyncEnumerable().<#=op#>Async((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+                var actual = await input.ToAsyncEnumerable().<#=op#>AwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
                 Assert.Equal(expected, actual);
 
                 input = Shuffle(input);
@@ -236,7 +236,7 @@ foreach (var op in new[] { "Min", "Max" })
 #endif
 
         [Fact]
-        public async Task <#=op#>_<#=t.Name#>_Nullable_<#=n#>_AllNull()
+        public async Task <#=op#>Async_<#=t.Name#>_Nullable_<#=n#>_AllNull()
         {
             var input = Enumerable.Repeat(default(<#=cs#>?), <#=n#>);
 
@@ -246,7 +246,7 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_Selector_<#=t.Name#>_Nullable_<#=n#>_AllNull()
+        public async Task <#=op#>Async_Selector_<#=t.Name#>_Nullable_<#=n#>_AllNull()
         {
             var input = Enumerable.Repeat(default(<#=cs#>?), <#=n#>);
 
@@ -256,29 +256,29 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_AsyncSelector_<#=t.Name#>_Nullable_<#=n#>_AllNull()
+        public async Task <#=op#>AwaitAsync_Selector_<#=t.Name#>_Nullable_<#=n#>_AllNull()
         {
             var input = Enumerable.Repeat(default(<#=cs#>?), <#=n#>);
 
             var expected = input.<#=op#>();
-            var actual = await input.ToAsyncEnumerable().<#=op#>Async(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+            var actual = await input.ToAsyncEnumerable().<#=op#>AwaitAsync(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
             Assert.Equal(expected, actual);
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task <#=op#>_AsyncSelectorWithCancellation_<#=t.Name#>_Nullable_<#=n#>_AllNull()
+        public async Task <#=op#>AwaitWithCancellationAsync_Selector_<#=t.Name#>_Nullable_<#=n#>_AllNull()
         {
             var input = Enumerable.Repeat(default(<#=cs#>?), <#=n#>);
 
             var expected = input.<#=op#>();
-            var actual = await input.ToAsyncEnumerable().<#=op#>Async((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+            var actual = await input.ToAsyncEnumerable().<#=op#>AwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
             Assert.Equal(expected, actual);
         }
 #endif
 
         [Fact]
-        public async Task <#=op#>_<#=t.Name#>_Nullable_<#=n#>_SomeNull()
+        public async Task <#=op#>Async_<#=t.Name#>_Nullable_<#=n#>_SomeNull()
         {
             var input = new <#=cs#>?[] { <#=valuesWithNull#> }.AsEnumerable();
 
@@ -293,7 +293,7 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_Selector_<#=t.Name#>_Nullable_<#=n#>_SomeNull()
+        public async Task <#=op#>Async_Selector_<#=t.Name#>_Nullable_<#=n#>_SomeNull()
         {
             var input = new <#=cs#>?[] { <#=valuesWithNull#> }.AsEnumerable();
 
@@ -308,14 +308,14 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_AsyncSelector_<#=t.Name#>_Nullable_<#=n#>_SomeNull()
+        public async Task <#=op#>AwaitAsync_Selector_<#=t.Name#>_Nullable_<#=n#>_SomeNull()
         {
             var input = new <#=cs#>?[] { <#=valuesWithNull#> }.AsEnumerable();
 
             for (var i = 0; i < <#=ShuffleCount#>; i++)
             {
                 var expected = input.<#=op#>();
-                var actual = await input.ToAsyncEnumerable().<#=op#>Async(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+                var actual = await input.ToAsyncEnumerable().<#=op#>AwaitAsync(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
                 Assert.Equal(expected, actual);
 
                 input = Shuffle(input);
@@ -324,14 +324,14 @@ foreach (var op in new[] { "Min", "Max" })
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task <#=op#>_AsyncSelectorWithCancellation_<#=t.Name#>_Nullable_<#=n#>_SomeNull()
+        public async Task <#=op#>AwaitWithCancellationAsync_Selector_<#=t.Name#>_Nullable_<#=n#>_SomeNull()
         {
             var input = new <#=cs#>?[] { <#=valuesWithNull#> }.AsEnumerable();
 
             for (var i = 0; i < <#=ShuffleCount#>; i++)
             {
                 var expected = input.<#=op#>();
-                var actual = await input.ToAsyncEnumerable().<#=op#>Async((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+                var actual = await input.ToAsyncEnumerable().<#=op#>AwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
                 Assert.Equal(expected, actual);
 
                 input = Shuffle(input);
@@ -350,7 +350,7 @@ foreach (var op in new[] { "Min", "Max" })
                 var valuesWithNull = string.Join(", ", getRandom(n * 42, n, -100, 100).Select((x, i) => i % 3 == 0 ? x.ToString() : (i % 3 == 1 ? "null" : toCSharp(t) + ".NaN")));
 #>
         [Fact]
-        public async Task <#=op#>_<#=t.Name#>_WithNaN_<#=n#>()
+        public async Task <#=op#>Async_<#=t.Name#>_WithNaN_<#=n#>()
         {
             var input = new <#=cs#>[] { <#=values#> }.AsEnumerable();
 
@@ -365,7 +365,7 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_Selector_<#=t.Name#>_WithNaN_<#=n#>()
+        public async Task <#=op#>Async_Selector_<#=t.Name#>_WithNaN_<#=n#>()
         {
             var input = new <#=cs#>[] { <#=values#> }.AsEnumerable();
 
@@ -380,14 +380,14 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_AsyncSelector_<#=t.Name#>_WithNaN_<#=n#>()
+        public async Task <#=op#>AwaitAsync_Selector_<#=t.Name#>_WithNaN_<#=n#>()
         {
             var input = new <#=cs#>[] { <#=values#> }.AsEnumerable();
 
             for (var i = 0; i < <#=ShuffleCount#>; i++)
             {
                 var expected = input.<#=op#>();
-                var actual = await input.ToAsyncEnumerable().<#=op#>Async(x => new ValueTask<<#=cs#>>(x), CancellationToken.None);
+                var actual = await input.ToAsyncEnumerable().<#=op#>AwaitAsync(x => new ValueTask<<#=cs#>>(x), CancellationToken.None);
                 Assert.Equal(expected, actual);
 
                 input = Shuffle(input);
@@ -396,14 +396,14 @@ foreach (var op in new[] { "Min", "Max" })
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task <#=op#>_AsyncSelectorWithCancellation_<#=t.Name#>_WithNaN_<#=n#>()
+        public async Task <#=op#>AwaitWithCancellationAsync_Selector_<#=t.Name#>_WithNaN_<#=n#>()
         {
             var input = new <#=cs#>[] { <#=values#> }.AsEnumerable();
 
             for (var i = 0; i < <#=ShuffleCount#>; i++)
             {
                 var expected = input.<#=op#>();
-                var actual = await input.ToAsyncEnumerable().<#=op#>Async((x, ct) => new ValueTask<<#=cs#>>(x), CancellationToken.None);
+                var actual = await input.ToAsyncEnumerable().<#=op#>AwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>>(x), CancellationToken.None);
                 Assert.Equal(expected, actual);
 
                 input = Shuffle(input);
@@ -412,7 +412,7 @@ foreach (var op in new[] { "Min", "Max" })
 #endif
 
         [Fact]
-        public async Task <#=op#>_<#=t.Name#>_WithNaN_<#=n#>_AllNaN()
+        public async Task <#=op#>Async_<#=t.Name#>_WithNaN_<#=n#>_AllNaN()
         {
             var input = Enumerable.Repeat(<#=toCSharp(t)#>.NaN, <#=n#>);
 
@@ -422,7 +422,7 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_Selector_<#=t.Name#>_WithNaN_<#=n#>_AllNaN()
+        public async Task <#=op#>Async_Selector_<#=t.Name#>_WithNaN_<#=n#>_AllNaN()
         {
             var input = Enumerable.Repeat(<#=toCSharp(t)#>.NaN, <#=n#>);
 
@@ -432,29 +432,29 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_AsyncSelector_<#=t.Name#>_WithNaN_<#=n#>_AllNaN()
+        public async Task <#=op#>AwaitAsync_Selector_<#=t.Name#>_WithNaN_<#=n#>_AllNaN()
         {
             var input = Enumerable.Repeat(<#=toCSharp(t)#>.NaN, <#=n#>);
 
             var expected = input.<#=op#>();
-            var actual = await input.ToAsyncEnumerable().<#=op#>Async(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+            var actual = await input.ToAsyncEnumerable().<#=op#>AwaitAsync(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
             Assert.Equal(expected, actual);
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task <#=op#>_AsyncSelectorWithCancellation_<#=t.Name#>_WithNaN_<#=n#>_AllNaN()
+        public async Task <#=op#>AwaitWithCancellationAsync_Selector_<#=t.Name#>_WithNaN_<#=n#>_AllNaN()
         {
             var input = Enumerable.Repeat(<#=toCSharp(t)#>.NaN, <#=n#>);
 
             var expected = input.<#=op#>();
-            var actual = await input.ToAsyncEnumerable().<#=op#>Async((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+            var actual = await input.ToAsyncEnumerable().<#=op#>AwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
             Assert.Equal(expected, actual);
         }
 #endif
 
         [Fact]
-        public async Task <#=op#>_<#=t.Name#>_WithNaN_Nullable_<#=n#>_NoNull()
+        public async Task <#=op#>Async_<#=t.Name#>_WithNaN_Nullable_<#=n#>_NoNull()
         {
             var input = new <#=cs#>?[] { <#=values#> }.AsEnumerable();
 
@@ -469,7 +469,7 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_NoNull()
+        public async Task <#=op#>Async_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_NoNull()
         {
             var input = new <#=cs#>?[] { <#=values#> }.AsEnumerable();
 
@@ -484,14 +484,14 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_AsyncSelector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_NoNull()
+        public async Task <#=op#>AwaitAsync_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_NoNull()
         {
             var input = new <#=cs#>?[] { <#=values#> }.AsEnumerable();
 
             for (var i = 0; i < <#=ShuffleCount#>; i++)
             {
                 var expected = input.<#=op#>();
-                var actual = await input.ToAsyncEnumerable().<#=op#>Async(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+                var actual = await input.ToAsyncEnumerable().<#=op#>AwaitAsync(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
                 Assert.Equal(expected, actual);
 
                 input = Shuffle(input);
@@ -500,14 +500,14 @@ foreach (var op in new[] { "Min", "Max" })
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task <#=op#>_AsyncSelectorWithCancellation_<#=t.Name#>_WithNaN_Nullable_<#=n#>_NoNull()
+        public async Task <#=op#>AwaitWithCancellationAsync_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_NoNull()
         {
             var input = new <#=cs#>?[] { <#=values#> }.AsEnumerable();
 
             for (var i = 0; i < <#=ShuffleCount#>; i++)
             {
                 var expected = input.<#=op#>();
-                var actual = await input.ToAsyncEnumerable().<#=op#>Async((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+                var actual = await input.ToAsyncEnumerable().<#=op#>AwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
                 Assert.Equal(expected, actual);
 
                 input = Shuffle(input);
@@ -516,7 +516,7 @@ foreach (var op in new[] { "Min", "Max" })
 #endif
 
         [Fact]
-        public async Task <#=op#>_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNull()
+        public async Task <#=op#>Async_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNull()
         {
             var input = Enumerable.Repeat(default(<#=cs#>?), <#=n#>);
 
@@ -526,7 +526,7 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNull()
+        public async Task <#=op#>Async_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNull()
         {
             var input = Enumerable.Repeat(default(<#=cs#>?), <#=n#>);
 
@@ -536,29 +536,29 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_AsyncSelector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNull()
+        public async Task <#=op#>AwaitAsync_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNull()
         {
             var input = Enumerable.Repeat(default(<#=cs#>?), <#=n#>);
 
             var expected = input.<#=op#>();
-            var actual = await input.ToAsyncEnumerable().<#=op#>Async(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+            var actual = await input.ToAsyncEnumerable().<#=op#>AwaitAsync(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
             Assert.Equal(expected, actual);
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task <#=op#>_AsyncSelectorWithCancellation_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNull()
+        public async Task <#=op#>AwaitWithCancellationAsync_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNull()
         {
             var input = Enumerable.Repeat(default(<#=cs#>?), <#=n#>);
 
             var expected = input.<#=op#>();
-            var actual = await input.ToAsyncEnumerable().<#=op#>Async((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+            var actual = await input.ToAsyncEnumerable().<#=op#>AwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
             Assert.Equal(expected, actual);
         }
 #endif
 
         [Fact]
-        public async Task <#=op#>_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNaN()
+        public async Task <#=op#>Async_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNaN()
         {
             var input = Enumerable.Repeat<<#=toCSharp(t)#>?>(<#=toCSharp(t)#>.NaN, <#=n#>);
 
@@ -568,7 +568,7 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNaN()
+        public async Task <#=op#>Async_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNaN()
         {
             var input = Enumerable.Repeat<<#=toCSharp(t)#>?>(<#=toCSharp(t)#>.NaN, <#=n#>);
 
@@ -578,29 +578,29 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_AsyncSelector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNaN()
+        public async Task <#=op#>AwaitAsync_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNaN()
         {
             var input = Enumerable.Repeat<<#=toCSharp(t)#>?>(<#=toCSharp(t)#>.NaN, <#=n#>);
 
             var expected = input.<#=op#>();
-            var actual = await input.ToAsyncEnumerable().<#=op#>Async(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+            var actual = await input.ToAsyncEnumerable().<#=op#>AwaitAsync(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
             Assert.Equal(expected, actual);
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task <#=op#>_AsyncSelectorWithCancellation_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNaN()
+        public async Task <#=op#>AwaitWithCancellationAsync_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_AllNaN()
         {
             var input = Enumerable.Repeat<<#=toCSharp(t)#>?>(<#=toCSharp(t)#>.NaN, <#=n#>);
 
             var expected = input.<#=op#>();
-            var actual = await input.ToAsyncEnumerable().<#=op#>Async((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+            var actual = await input.ToAsyncEnumerable().<#=op#>AwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
             Assert.Equal(expected, actual);
         }
 #endif
 
         [Fact]
-        public async Task <#=op#>_<#=t.Name#>_WithNaN_Nullable_<#=n#>_SomeNull()
+        public async Task <#=op#>Async_<#=t.Name#>_WithNaN_Nullable_<#=n#>_SomeNull()
         {
             var input = new <#=cs#>?[] { <#=valuesWithNull#> }.AsEnumerable();
 
@@ -615,7 +615,7 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_SomeNull()
+        public async Task <#=op#>Async_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_SomeNull()
         {
             var input = new <#=cs#>?[] { <#=valuesWithNull#> }.AsEnumerable();
 
@@ -630,14 +630,14 @@ foreach (var op in new[] { "Min", "Max" })
         }
 
         [Fact]
-        public async Task <#=op#>_AsyncSelector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_SomeNull()
+        public async Task <#=op#>AwaitAsync_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_SomeNull()
         {
             var input = new <#=cs#>?[] { <#=valuesWithNull#> }.AsEnumerable();
 
             for (var i = 0; i < <#=ShuffleCount#>; i++)
             {
                 var expected = input.<#=op#>();
-                var actual = await input.ToAsyncEnumerable().<#=op#>Async(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+                var actual = await input.ToAsyncEnumerable().<#=op#>AwaitAsync(x => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
                 Assert.Equal(expected, actual);
 
                 input = Shuffle(input);
@@ -646,14 +646,14 @@ foreach (var op in new[] { "Min", "Max" })
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task <#=op#>_AsyncSelectorWithCancellation_<#=t.Name#>_WithNaN_Nullable_<#=n#>_SomeNull()
+        public async Task <#=op#>AwaitWithCancellationAsync_Selector_<#=t.Name#>_WithNaN_Nullable_<#=n#>_SomeNull()
         {
             var input = new <#=cs#>?[] { <#=valuesWithNull#> }.AsEnumerable();
 
             for (var i = 0; i < <#=ShuffleCount#>; i++)
             {
                 var expected = input.<#=op#>();
-                var actual = await input.ToAsyncEnumerable().<#=op#>Async((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
+                var actual = await input.ToAsyncEnumerable().<#=op#>AwaitWithCancellationAsync((x, ct) => new ValueTask<<#=cs#>?>(x), CancellationToken.None);
                 Assert.Equal(expected, actual);
 
                 input = Shuffle(input);

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/OrderBy.Generated.tt

@@ -15,6 +15,16 @@ Func<bool, bool, bool, bool, string, string> getAsyncMethod = (then, desc, async
 
     var arg = async ? (cancel ? "(x, ct) => " : "x => ") + "new ValueTask<int>(" + body + ")" : "x => " + body;
 
+    if (async)
+    {
+        mtd += "Await";
+
+        if (cancel)
+        {
+            mtd += "WithCancellation";
+        }
+    }
+
     return "." + mtd + "(" + arg + ")";
 };
 

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/OrderBy.cs

@@ -19,13 +19,13 @@ namespace Tests
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderBy(Return42, default(Func<int, int>)));
 
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderBy<int, int>(default, x => x, Comparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderBy(Return42, default(Func<int, int>), Comparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderBy(Return42, default, Comparer<int>.Default));
 
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending<int, int>(default, x => x));
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending(Return42, default(Func<int, int>)));
 
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending<int, int>(default, x => x, Comparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending(Return42, default(Func<int, int>), Comparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.OrderByDescending(Return42, default, Comparer<int>.Default));
 
             var xs = Return42.OrderBy(x => x);
 
@@ -33,13 +33,13 @@ namespace Tests
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenBy(xs, default(Func<int, int>)));
 
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenBy<int, int>(default, x => x, Comparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenBy(xs, default(Func<int, int>), Comparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenBy(xs, default, Comparer<int>.Default));
 
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending<int, int>(default, x => x));
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending(xs, default(Func<int, int>)));
 
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending<int, int>(default, x => x, Comparer<int>.Default));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending(xs, default(Func<int, int>), Comparer<int>.Default));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.ThenByDescending(xs, default, Comparer<int>.Default));
         }
 
         [Fact]

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Select.cs

@@ -188,7 +188,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Sync_SelectSelect_AsyncIterator()
+        public async Task Select_Sync_SelectSelectAwaitIterator()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
             var ys = xs.Select(i => i + 3).Select(x => (char)('a' + x));
@@ -282,19 +282,19 @@ namespace Tests
         }
 
         [Fact]
-        public void Select_Async_Null()
+        public void SelectAwait_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Select<int, int>(default, x => new ValueTask<int>(x)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Select(default, (int x, int i) => new ValueTask<int>(x)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Select(Return42, default(Func<int, ValueTask<int>>)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Select(Return42, default(Func<int, int, ValueTask<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectAwait<int, int>(default, x => new ValueTask<int>(x)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectAwait(default, (int x, int i) => new ValueTask<int>(x)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectAwait(Return42, default(Func<int, ValueTask<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectAwait(Return42, default(Func<int, int, ValueTask<int>>)));
         }
 
         [Fact]
-        public async Task Select_Async_Simple()
+        public async Task SelectAwait_Simple()
         {
             var xs = ToAsyncEnumerable(new[] { 0, 1, 2 });
-            var ys = xs.Select(x => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwait(x => new ValueTask<char>((char)('a' + x)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'a');
@@ -304,10 +304,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Simple_IList()
+        public async Task SelectAwait_Simple_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 });
-            var ys = xs.Select(x => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwait(x => new ValueTask<char>((char)('a' + x)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'a');
@@ -317,10 +317,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Simple_AsyncIterator()
+        public async Task SelectAwait_Simple_AsyncIterator()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
-            var ys = xs.Select(x => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwait(x => new ValueTask<char>((char)('a' + x)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'a');
@@ -330,10 +330,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Indexed()
+        public async Task SelectAwait_Indexed()
         {
             var xs = ToAsyncEnumerable(new[] { 8, 5, 7 });
-            var ys = xs.Select((x, i) => new ValueTask<char>((char)('a' + i)));
+            var ys = xs.SelectAwait((x, i) => new ValueTask<char>((char)('a' + i)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'a');
@@ -343,10 +343,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Indexed_IList()
+        public async Task SelectAwait_Indexed_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 });
-            var ys = xs.Select((x, i) => new ValueTask<char>((char)('a' + i)));
+            var ys = xs.SelectAwait((x, i) => new ValueTask<char>((char)('a' + i)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'a');
@@ -356,10 +356,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Indexed_AsyncIterator()
+        public async Task SelectAwait_Indexed_AsyncIterator()
         {
             var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable();
-            var ys = xs.Select((x, i) => new ValueTask<char>((char)('a' + i)));
+            var ys = xs.SelectAwait((x, i) => new ValueTask<char>((char)('a' + i)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'a');
@@ -369,70 +369,70 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Throws_Selector()
+        public async Task SelectAwait_Throws_Selector()
         {
             var xs = ToAsyncEnumerable(new[] { 0, 1, 2 });
-            var ys = xs.Select(x => new ValueTask<int>(1 / x));
+            var ys = xs.SelectAwait(x => new ValueTask<int>(1 / x));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]
-        public async Task Select_Async_Throws_Selector_IList()
+        public async Task SelectAwait_Throws_Selector_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 });
-            var ys = xs.Select(x => new ValueTask<int>(1 / x));
+            var ys = xs.SelectAwait(x => new ValueTask<int>(1 / x));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]
-        public async Task Select_Async_Throws_Selector_AsyncIterator()
+        public async Task SelectAwait_Throws_Selector_AsyncIterator()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
-            var ys = xs.Select(x => new ValueTask<int>(1 / x));
+            var ys = xs.SelectAwait(x => new ValueTask<int>(1 / x));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]
-        public async Task Select_Async_Indexed_Throws_Selector()
+        public async Task SelectAwait_Indexed_Throws_Selector()
         {
             var xs = ToAsyncEnumerable(new[] { 8, 5, 7 });
-            var ys = xs.Select((x, i) => new ValueTask<int>(1 / i));
+            var ys = xs.SelectAwait((x, i) => new ValueTask<int>(1 / i));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]
-        public async Task Select_Async_Indexed_Throws_Selector_IList()
+        public async Task SelectAwait_Indexed_Throws_Selector_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 });
-            var ys = xs.Select((x, i) => new ValueTask<int>(1 / i));
+            var ys = xs.SelectAwait((x, i) => new ValueTask<int>(1 / i));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]
-        public async Task Select_Async_Indexed_Throws_Selector_AsyncIterator()
+        public async Task SelectAwait_Indexed_Throws_Selector_AsyncIterator()
         {
             var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable();
-            var ys = xs.Select((x, i) => new ValueTask<int>(1 / i));
+            var ys = xs.SelectAwait((x, i) => new ValueTask<int>(1 / i));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]
-        public async Task Select_Async_SelectSelect()
+        public async Task SelectAwait_SelectSelect()
         {
             var xs = ToAsyncEnumerable(new[] { 0, 1, 2 });
-            var ys = xs.Select(i => new ValueTask<int>(i + 3)).Select(x => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwait(i => new ValueTask<int>(i + 3)).SelectAwait(x => new ValueTask<char>((char)('a' + x)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'd');
@@ -442,10 +442,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_SelectSelect_IList()
+        public async Task SelectAwait_SelectSelect_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 });
-            var ys = xs.Select(i => new ValueTask<int>(i + 3)).Select(x => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwait(i => new ValueTask<int>(i + 3)).SelectAwait(x => new ValueTask<char>((char)('a' + x)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'd');
@@ -455,10 +455,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_SelectSelect_AsyncIterator()
+        public async Task SelectAwait_SelectSelectAwaitIterator()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
-            var ys = xs.Select(i => new ValueTask<int>(i + 3)).Select(x => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwait(i => new ValueTask<int>(i + 3)).SelectAwait(x => new ValueTask<char>((char)('a' + x)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'd');
@@ -468,104 +468,102 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_SequenceIdentity()
+        public async Task SelectAwait_SequenceIdentity()
         {
             var xs = ToAsyncEnumerable(new[] { 1, 2, 3 });
-            var ys = xs.Select(x => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwait(x => new ValueTask<char>((char)('a' + x)));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Select_Async_SequenceIdentity_IList()
+        public async Task SelectAwait_SequenceIdentity_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3 });
-            var ys = xs.Select(x => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwait(x => new ValueTask<char>((char)('a' + x)));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Select_Async_SequenceIdentity_AsyncIterator()
+        public async Task SelectAwait_SequenceIdentity_AsyncIterator()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
-            var ys = xs.Select(x => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwait(x => new ValueTask<char>((char)('a' + x)));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Select_Async_Indexed_SequenceIdentity()
+        public async Task SelectAwait_Indexed_SequenceIdentity()
         {
             var xs = ToAsyncEnumerable(new[] { 8, 5, 7 });
-            var ys = xs.Select((x, i) => new ValueTask<char>((char)('a' + i)));
+            var ys = xs.SelectAwait((x, i) => new ValueTask<char>((char)('a' + i)));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Select_Async_Indexed_SequenceIdentity_IList()
+        public async Task SelectAwait_Indexed_SequenceIdentity_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 });
-            var ys = xs.Select((x, i) => new ValueTask<char>((char)('a' + i)));
+            var ys = xs.SelectAwait((x, i) => new ValueTask<char>((char)('a' + i)));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Select_Async_Indexed_SequenceIdentity_AsyncIterator()
+        public async Task SelectAwait_Indexed_SequenceIdentity_AsyncIterator()
         {
             var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable();
-            var ys = xs.Select((x, i) => new ValueTask<char>((char)('a' + i)));
+            var ys = xs.SelectAwait((x, i) => new ValueTask<char>((char)('a' + i)));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Select_Async_IList_Count()
+        public async Task SelectAwait_IList_Count()
         {
             var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
-            var ys = xs.Select(x => new ValueTask<int>(x * 2));
+            var ys = xs.SelectAwait(x => new ValueTask<int>(x * 2));
 
             Assert.Equal(5, await ys.CountAsync());
         }
 
         [Fact]
-        public async Task Select_Async_IList_ToList()
+        public async Task SelectAwait_IList_ToList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
-            var ys = xs.Select(x => new ValueTask<int>(x * 2));
+            var ys = xs.SelectAwait(x => new ValueTask<int>(x * 2));
 
             Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToListAsync());
         }
 
         [Fact]
-        public async Task Select_Async_IList_ToArray()
+        public async Task SelectAwait_IList_ToArray()
         {
             var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
-            var ys = xs.Select(x => new ValueTask<int>(x * 2));
+            var ys = xs.SelectAwait(x => new ValueTask<int>(x * 2));
 
             Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToArrayAsync());
         }
 
 #if !NO_DEEP_CANCELLATION
 
-        // REVIEW: These overloads are problematic for type inference. E.g. xs.Select((x, ct) => ...) is ambiguous.
-
         [Fact]
-        public void Select_Async_Cancel_Null()
+        public void SelectAwaitWithCancellation_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Select(default, (int x, CancellationToken ct) => new ValueTask<int>(x)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Select(default, (int x, int i, CancellationToken ct) => new ValueTask<int>(x)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Select(Return42, default(Func<int, CancellationToken, ValueTask<int>>)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Select(Return42, default(Func<int, int, CancellationToken, ValueTask<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectAwaitWithCancellation(default, (int x, CancellationToken ct) => new ValueTask<int>(x)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectAwaitWithCancellation(default, (int x, int i, CancellationToken ct) => new ValueTask<int>(x)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectAwaitWithCancellation(Return42, default(Func<int, CancellationToken, ValueTask<int>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SelectAwaitWithCancellation(Return42, default(Func<int, int, CancellationToken, ValueTask<int>>)));
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Simple()
+        public async Task SelectAwaitWithCancellation_Simple()
         {
             var xs = ToAsyncEnumerable(new[] { 0, 1, 2 });
-            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'a');
@@ -575,10 +573,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Simple_IList()
+        public async Task SelectAwaitWithCancellation_Simple_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 });
-            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'a');
@@ -588,10 +586,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Simple_Async_CancelIterator()
+        public async Task SelectAwaitWithCancellation_Simple_Async_CancelIterator()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
-            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'a');
@@ -601,10 +599,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Indexed()
+        public async Task SelectAwaitWithCancellation_Indexed()
         {
             var xs = ToAsyncEnumerable(new[] { 8, 5, 7 });
-            var ys = xs.Select((x, i, ct) => new ValueTask<char>((char)('a' + i)));
+            var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask<char>((char)('a' + i)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'a');
@@ -614,10 +612,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Indexed_IList()
+        public async Task SelectAwaitWithCancellation_Indexed_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 });
-            var ys = xs.Select((x, i, ct) => new ValueTask<char>((char)('a' + i)));
+            var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask<char>((char)('a' + i)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'a');
@@ -627,10 +625,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Indexed_Async_CancelIterator()
+        public async Task SelectAwaitWithCancellation_Indexed_Async_CancelIterator()
         {
             var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable();
-            var ys = xs.Select((x, i, ct) => new ValueTask<char>((char)('a' + i)));
+            var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask<char>((char)('a' + i)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'a');
@@ -640,70 +638,70 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Throws_Selector()
+        public async Task SelectAwaitWithCancellation_Throws_Selector()
         {
             var xs = ToAsyncEnumerable(new[] { 0, 1, 2 });
-            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<int>(1 / x));
+            var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<int>(1 / x));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Throws_Selector_IList()
+        public async Task SelectAwaitWithCancellation_Throws_Selector_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 });
-            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<int>(1 / x));
+            var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<int>(1 / x));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Throws_Selector_Async_CancelIterator()
+        public async Task SelectAwaitWithCancellation_Throws_Selector_Async_CancelIterator()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
-            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<int>(1 / x));
+            var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<int>(1 / x));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Indexed_Throws_Selector()
+        public async Task SelectAwaitWithCancellation_Indexed_Throws_Selector()
         {
             var xs = ToAsyncEnumerable(new[] { 8, 5, 7 });
-            var ys = xs.Select((x, i, ct) => new ValueTask<int>(1 / i));
+            var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask<int>(1 / i));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Indexed_Throws_Selector_IList()
+        public async Task SelectAwaitWithCancellation_Indexed_Throws_Selector_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 });
-            var ys = xs.Select((x, i, ct) => new ValueTask<int>(1 / i));
+            var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask<int>(1 / i));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Indexed_Throws_Selector_Async_CancelIterator()
+        public async Task SelectAwaitWithCancellation_Indexed_Throws_Selector_Async_CancelIterator()
         {
             var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable();
-            var ys = xs.Select((x, i, ct) => new ValueTask<int>(1 / i));
+            var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask<int>(1 / i));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync<DivideByZeroException>(e.MoveNextAsync().AsTask());
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_SelectSelect()
+        public async Task SelectAwaitWithCancellation_SelectSelect()
         {
             var xs = ToAsyncEnumerable(new[] { 0, 1, 2 });
-            var ys = xs.Select((int i, CancellationToken ct) => new ValueTask<int>(i + 3)).Select((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwaitWithCancellation((int i, CancellationToken ct) => new ValueTask<int>(i + 3)).SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'd');
@@ -713,10 +711,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_SelectSelect_IList()
+        public async Task SelectAwaitWithCancellation_SelectSelect_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 });
-            var ys = xs.Select((int i, CancellationToken ct) => new ValueTask<int>(i + 3)).Select((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwaitWithCancellation((int i, CancellationToken ct) => new ValueTask<int>(i + 3)).SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'd');
@@ -726,10 +724,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_SelectSelect_Async_CancelIterator()
+        public async Task SelectAwaitWithCancellation_SelectSelectAwait_CancelIterator()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
-            var ys = xs.Select((int i, CancellationToken ct) => new ValueTask<int>(i + 3)).Select((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwaitWithCancellation((int i, CancellationToken ct) => new ValueTask<int>(i + 3)).SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 'd');
@@ -739,82 +737,82 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_SequenceIdentity()
+        public async Task SelectAwaitWithCancellation_SequenceIdentity()
         {
             var xs = ToAsyncEnumerable(new[] { 1, 2, 3 });
-            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_SequenceIdentity_IList()
+        public async Task SelectAwaitWithCancellation_SequenceIdentity_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3 });
-            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_SequenceIdentity_Async_CancelIterator()
+        public async Task SelectAwaitWithCancellation_SequenceIdentity_Async_CancelIterator()
         {
             var xs = new[] { 0, 1, 2 }.ToAsyncEnumerable();
-            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
+            var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<char>((char)('a' + x)));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Indexed_SequenceIdentity()
+        public async Task SelectAwaitWithCancellation_Indexed_SequenceIdentity()
         {
             var xs = ToAsyncEnumerable(new[] { 8, 5, 7 });
-            var ys = xs.Select((x, i, ct) => new ValueTask<char>((char)('a' + i)));
+            var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask<char>((char)('a' + i)));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Indexed_SequenceIdentity_IList()
+        public async Task SelectAwaitWithCancellation_Indexed_SequenceIdentity_IList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 });
-            var ys = xs.Select((x, i, ct) => new ValueTask<char>((char)('a' + i)));
+            var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask<char>((char)('a' + i)));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_Indexed_SequenceIdentity_Async_CancelIterator()
+        public async Task SelectAwaitWithCancellation_Indexed_SequenceIdentity_Async_CancelIterator()
         {
             var xs = new[] { 8, 5, 7 }.ToAsyncEnumerable();
-            var ys = xs.Select((x, i, ct) => new ValueTask<char>((char)('a' + i)));
+            var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask<char>((char)('a' + i)));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_IList_Count()
+        public async Task SelectAwaitWithCancellation_IList_Count()
         {
             var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
-            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<int>(x * 2));
+            var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<int>(x * 2));
 
             Assert.Equal(5, await ys.CountAsync());
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_IList_ToList()
+        public async Task SelectAwaitWithCancellation_IList_ToList()
         {
             var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
-            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<int>(x * 2));
+            var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<int>(x * 2));
 
             Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToListAsync());
         }
 
         [Fact]
-        public async Task Select_Async_Cancel_IList_ToArray()
+        public async Task SelectAwaitWithCancellation_IList_ToArray()
         {
             var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 });
-            var ys = xs.Select((int x, CancellationToken ct) => new ValueTask<int>(x * 2));
+            var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<int>(x * 2));
 
             Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToArrayAsync());
         }

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Single.cs

@@ -76,7 +76,7 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAsync(Return42, default(Func<int, bool>)).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAsync<int>(default, x => true, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAsync(Return42, default(Func<int, bool>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
@@ -123,106 +123,106 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_Null()
+        public async Task SingleAwaitAsync_Predicate_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAsync(Return42, default(Func<int, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAwaitAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAwaitAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAsync(Return42, default(Func<int, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAwaitAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAwaitAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_Empty()
+        public async Task SingleAwaitAsync_Predicate_Empty()
         {
-            var res = AsyncEnumerable.Empty<int>().SingleAsync(x => new ValueTask<bool>(true));
+            var res = AsyncEnumerable.Empty<int>().SingleAwaitAsync(x => new ValueTask<bool>(true));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_NoMatch()
+        public async Task SingleAwaitAsync_Predicate_NoMatch()
         {
-            var res = Return42.SingleAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = Return42.SingleAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_Simple()
+        public async Task SingleAwaitAsync_Predicate_Simple()
         {
-            var res = Return42.SingleAsync(x => new ValueTask<bool>(x % 2 == 0));
+            var res = Return42.SingleAwaitAsync(x => new ValueTask<bool>(x % 2 == 0));
             Assert.Equal(42, await res);
         }
 
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_Throws()
+        public async Task SingleAwaitAsync_Predicate_Throws()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).SingleAsync(x => new ValueTask<bool>(true));
+            var res = Throw<int>(ex).SingleAwaitAsync(x => new ValueTask<bool>(true));
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_OneMatch()
+        public async Task SingleAwaitAsync_Predicate_OneMatch()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_Throw_MoreThanOne()
+        public async Task SingleAwaitAsync_Predicate_Throw_MoreThanOne()
         {
-            var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().SingleAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().SingleAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_Cancel_Null()
+        public async Task SingleAwaitWithCancellationAsync_Predicate_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleAwaitWithCancellationAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_Cancel_Empty()
+        public async Task SingleAwaitWithCancellationAsync_Predicate_Empty()
         {
-            var res = AsyncEnumerable.Empty<int>().SingleAsync((x, ct) => new ValueTask<bool>(true));
+            var res = AsyncEnumerable.Empty<int>().SingleAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_Cancel_NoMatch()
+        public async Task SingleAwaitWithCancellationAsync_Predicate_NoMatch()
         {
-            var res = Return42.SingleAsync((x, ct) => new ValueTask<bool>(x % 2 != 0));
+            var res = Return42.SingleAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_Cancel_Simple()
+        public async Task SingleAwaitWithCancellationAsync_Predicate_Simple()
         {
-            var res = Return42.SingleAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
+            var res = Return42.SingleAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
             Assert.Equal(42, await res);
         }
 
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_Cancel_Throws()
+        public async Task SingleAwaitWithCancellationAsync_Predicate_Throws()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).SingleAsync((x, ct) => new ValueTask<bool>(true));
+            var res = Throw<int>(ex).SingleAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true));
             await AssertThrowsAsync(res, ex);
         }
 
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_Cancel_OneMatch()
+        public async Task SingleAwaitWithCancellationAsync_Predicate_OneMatch()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleAsync((x, ct) => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task SingleAsync_AsyncPredicate_Cancel_Throw_MoreThanOne()
+        public async Task SingleAwaitWithCancellationAsync_Predicate_Throw_MoreThanOne()
         {
-            var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().SingleAsync((x, ct) => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 23, 45, 90 }.ToAsyncEnumerable().SingleAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 #endif

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/SingleOrDefault.cs

@@ -76,7 +76,7 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAsync(Return42, default(Func<int, bool>)).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAsync<int>(default, x => true, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAsync(Return42, default(Func<int, bool>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
@@ -130,120 +130,120 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_Null()
+        public async Task SingleOrDefaultAwaitAsync_Predicate_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAsync(Return42, default(Func<int, ValueTask<bool>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAwaitAsync<int>(default, x => new ValueTask<bool>(true)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAwaitAsync(Return42, default).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAsync(Return42, default(Func<int, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAwaitAsync<int>(default, x => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAwaitAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_Empty()
+        public async Task SingleOrDefaultAwaitAsync_Predicate_Empty()
         {
-            var res = AsyncEnumerable.Empty<int>().SingleOrDefaultAsync(x => new ValueTask<bool>(true));
+            var res = AsyncEnumerable.Empty<int>().SingleOrDefaultAwaitAsync(x => new ValueTask<bool>(true));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_NoMatch_Single()
+        public async Task SingleOrDefaultAwaitAsync_Predicate_NoMatch_Single()
         {
-            var res = Return42.SingleOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = Return42.SingleOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_OneMatch_Single()
+        public async Task SingleOrDefaultAwaitAsync_Predicate_OneMatch_Single()
         {
-            var res = Return42.SingleOrDefaultAsync(x => new ValueTask<bool>(x % 2 == 0));
+            var res = Return42.SingleOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 == 0));
             Assert.Equal(42, await res);
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_OneMatch_Many()
+        public async Task SingleOrDefaultAwaitAsync_Predicate_OneMatch_Many()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefaultAsync(x => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefaultAwaitAsync(x => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_NoMatch_Many()
+        public async Task SingleOrDefaultAwaitAsync_Predicate_NoMatch_Many()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefaultAsync(x => new ValueTask<bool>(x < 10));
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefaultAwaitAsync(x => new ValueTask<bool>(x < 10));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_MoreThanOne()
+        public async Task SingleOrDefaultAwaitAsync_Predicate_MoreThanOne()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefaultAsync(x => new ValueTask<bool>(true));
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefaultAwaitAsync(x => new ValueTask<bool>(true));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_Throws_Source()
+        public async Task SingleOrDefaultAwaitAsync_Predicate_Throws_Source()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).SingleOrDefaultAsync(x => new ValueTask<bool>(true));
+            var res = Throw<int>(ex).SingleOrDefaultAwaitAsync(x => new ValueTask<bool>(true));
             await AssertThrowsAsync(res, ex);
         }
 
 #if !NO_DEEP_CANCELLATION
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_Cancel_Null()
+        public async Task SingleOrDefaultAwaitWithCancellationAsync_Predicate_Null()
         {
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAsync(Return42, default(Func<int, CancellationToken, ValueTask<bool>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAwaitWithCancellationAsync<int>(default, (x, ct) => new ValueTask<bool>(true), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SingleOrDefaultAwaitWithCancellationAsync(Return42, default, CancellationToken.None).AsTask());
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_Cancel_Empty()
+        public async Task SingleOrDefaultAwaitWithCancellationAsync_Predicate_Empty()
         {
-            var res = AsyncEnumerable.Empty<int>().SingleOrDefaultAsync((x, ct) => new ValueTask<bool>(true));
+            var res = AsyncEnumerable.Empty<int>().SingleOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_Cancel_NoMatch_Single()
+        public async Task SingleOrDefaultAwaitWithCancellationAsync_Predicate_NoMatch_Single()
         {
-            var res = Return42.SingleOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0));
+            var res = Return42.SingleOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_Cancel_OneMatch_Single()
+        public async Task SingleOrDefaultAwaitWithCancellationAsync_Predicate_OneMatch_Single()
         {
-            var res = Return42.SingleOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
+            var res = Return42.SingleOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 == 0));
             Assert.Equal(42, await res);
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_Cancel_OneMatch_Many()
+        public async Task SingleOrDefaultAwaitWithCancellationAsync_Predicate_OneMatch_Many()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefaultAsync((x, ct) => new ValueTask<bool>(x % 2 != 0));
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x % 2 != 0));
             Assert.Equal(45, await res);
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_Cancel_NoMatch_Many()
+        public async Task SingleOrDefaultAwaitWithCancellationAsync_Predicate_NoMatch_Many()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefaultAsync((x, ct) => new ValueTask<bool>(x < 10));
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(x < 10));
             Assert.Equal(0, await res);
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_Cancel_MoreThanOne()
+        public async Task SingleOrDefaultAwaitWithCancellationAsync_Predicate_MoreThanOne()
         {
-            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefaultAsync((x, ct) => new ValueTask<bool>(true));
+            var res = new[] { 42, 45, 90 }.ToAsyncEnumerable().SingleOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true));
             await AssertThrowsAsync<InvalidOperationException>(res.AsTask());
         }
 
         [Fact]
-        public async Task SingleOrDefaultAsync_AsyncPredicate_Cancel_Throws_Source()
+        public async Task SingleOrDefaultAwaitWithCancellationAsync_Predicate_Throws_Source()
         {
             var ex = new Exception("Bang!");
-            var res = Throw<int>(ex).SingleOrDefaultAsync((x, ct) => new ValueTask<bool>(true));
+            var res = Throw<int>(ex).SingleOrDefaultAwaitWithCancellationAsync((x, ct) => new ValueTask<bool>(true));
             await AssertThrowsAsync(res, ex);
         }
 #endif

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/SkipWhile.cs

@@ -13,7 +13,7 @@ namespace Tests
     public class SkipWhile : AsyncEnumerableTests
     {
         [Fact]
-        public void SkipWhile_Sync_Null()
+        public void SkipWhile_Null()
         {
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(default, x => true));
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(default, (x, i) => true));
@@ -22,7 +22,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Sync_Simple1()
+        public async Task SkipWhile_Simple1()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile(x => x < 3);
@@ -34,7 +34,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Sync_Simple2()
+        public async Task SkipWhile_Simple2()
         {
             var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile(x => x < 3);
@@ -49,7 +49,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Sync_False()
+        public async Task SkipWhile_False()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile(x => false);
@@ -63,7 +63,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Sync_True()
+        public async Task SkipWhile_True()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile(x => true);
@@ -73,7 +73,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Sync_Throws_Predicate()
+        public async Task SkipWhile_Throws_Predicate()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -84,7 +84,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Sync_Indexed()
+        public async Task SkipWhile_Indexed()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile((x, i) => i < 2);
@@ -96,7 +96,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Sync_Indexed_False()
+        public async Task SkipWhile_Indexed_False()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile((x, i) => false);
@@ -110,7 +110,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Sync_Indexed_True()
+        public async Task SkipWhile_Indexed_True()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile((x, i) => true);
@@ -120,7 +120,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Sync_Indexed_Throws_Predicate()
+        public async Task SkipWhile_Indexed_Throws_Predicate()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -131,7 +131,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Sync_SequenceIdentity()
+        public async Task SkipWhile_SequenceIdentity()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile(x => x < 3);
@@ -140,7 +140,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Sync_Indexed_SequenceIdentity()
+        public async Task SkipWhile_Indexed_SequenceIdentity()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.SkipWhile((x, i) => false);
@@ -149,19 +149,19 @@ namespace Tests
         }
 
         [Fact]
-        public void SkipWhile_Async_Null()
+        public void SkipWhileAwait_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(default, x => new ValueTask<bool>(true)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile(default, (int x, int i) => new ValueTask<bool>(true)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile(Return42, default(Func<int, ValueTask<bool>>)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile(Return42, default(Func<int, int, ValueTask<bool>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhileAwait<int>(default, x => new ValueTask<bool>(true)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhileAwait(default, (int x, int i) => new ValueTask<bool>(true)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhileAwait(Return42, default(Func<int, ValueTask<bool>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhileAwait(Return42, default(Func<int, int, ValueTask<bool>>)));
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Simple1()
+        public async Task SkipWhileAwait_Simple1()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile(x => new ValueTask<bool>(x < 3));
+            var ys = xs.SkipWhileAwait(x => new ValueTask<bool>(x < 3));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 3);
@@ -170,10 +170,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Simple2()
+        public async Task SkipWhileAwait_Simple2()
         {
             var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile(x => new ValueTask<bool>(x < 3));
+            var ys = xs.SkipWhileAwait(x => new ValueTask<bool>(x < 3));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 3);
@@ -185,10 +185,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Async_False()
+        public async Task SkipWhileAwait_False()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile(x => new ValueTask<bool>(false));
+            var ys = xs.SkipWhileAwait(x => new ValueTask<bool>(false));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -199,31 +199,31 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Async_True()
+        public async Task SkipWhileAwait_True()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile(x => new ValueTask<bool>(true));
+            var ys = xs.SkipWhileAwait(x => new ValueTask<bool>(true));
 
             var e = ys.GetAsyncEnumerator();
             await NoNextAsync(e);
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Throws_Predicate()
+        public async Task SkipWhileAwait_Throws_Predicate()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile(new Func<int, ValueTask<bool>>(x => { throw ex; }));
+            var ys = xs.SkipWhileAwait(new Func<int, ValueTask<bool>>(x => { throw ex; }));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Indexed()
+        public async Task SkipWhileAwait_Indexed()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((x, i) => new ValueTask<bool>(i < 2));
+            var ys = xs.SkipWhileAwait((x, i) => new ValueTask<bool>(i < 2));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 3);
@@ -232,10 +232,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Indexed_False()
+        public async Task SkipWhileAwait_Indexed_False()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((int x, int i) => new ValueTask<bool>(false));
+            var ys = xs.SkipWhileAwait((int x, int i) => new ValueTask<bool>(false));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -246,40 +246,40 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Indexed_True()
+        public async Task SkipWhileAwait_Indexed_True()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((int x, int i) => new ValueTask<bool>(true));
+            var ys = xs.SkipWhileAwait((int x, int i) => new ValueTask<bool>(true));
 
             var e = ys.GetAsyncEnumerator();
             await NoNextAsync(e);
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Indexed_Throws_Predicate()
+        public async Task SkipWhileAwait_Indexed_Throws_Predicate()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile(new Func<int, int, ValueTask<bool>>((x, i) => { throw ex; }));
+            var ys = xs.SkipWhileAwait(new Func<int, int, ValueTask<bool>>((x, i) => { throw ex; }));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
-        public async Task SkipWhile_Async_SequenceIdentity()
+        public async Task SkipWhileAwait_SequenceIdentity()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile(x => new ValueTask<bool>(x < 3));
+            var ys = xs.SkipWhileAwait(x => new ValueTask<bool>(x < 3));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Indexed_SequenceIdentity()
+        public async Task SkipWhileAwait_Indexed_SequenceIdentity()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((int x, int i) => new ValueTask<bool>(false));
+            var ys = xs.SkipWhileAwait((int x, int i) => new ValueTask<bool>(false));
 
             await SequenceIdentity(ys);
         }
@@ -287,19 +287,19 @@ namespace Tests
 #if !NO_DEEP_CANCELLATION
 
         [Fact]
-        public void SkipWhile_Async_Cancel_Null()
+        public void SkipWhileAwaitWithCancellation_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile(default, (int x, CancellationToken ct) => new ValueTask<bool>(true)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile<int>(default, (x, i, ct) => new ValueTask<bool>(true)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile(Return42, default(Func<int, CancellationToken, ValueTask<bool>>)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhile(Return42, default(Func<int, int, CancellationToken, ValueTask<bool>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhileAwaitWithCancellation(default, (int x, CancellationToken ct) => new ValueTask<bool>(true)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhileAwaitWithCancellation<int>(default, (x, i, ct) => new ValueTask<bool>(true)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhileAwaitWithCancellation(Return42, default(Func<int, CancellationToken, ValueTask<bool>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.SkipWhileAwaitWithCancellation(Return42, default(Func<int, int, CancellationToken, ValueTask<bool>>)));
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Cancel_Simple1()
+        public async Task SkipWhileAwaitWithCancellation_Simple1()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((int x, CancellationToken ct) => new ValueTask<bool>(x < 3));
+            var ys = xs.SkipWhileAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(x < 3));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 3);
@@ -308,10 +308,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Cancel_Simple2()
+        public async Task SkipWhileAwaitWithCancellation_Simple2()
         {
             var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((int x, CancellationToken ct) => new ValueTask<bool>(x < 3));
+            var ys = xs.SkipWhileAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(x < 3));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 3);
@@ -323,10 +323,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Cancel_False()
+        public async Task SkipWhileAwaitWithCancellation_False()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((int x, CancellationToken ct) => new ValueTask<bool>(false));
+            var ys = xs.SkipWhileAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(false));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -337,31 +337,31 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Cancel_True()
+        public async Task SkipWhileAwaitWithCancellation_True()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((int x, CancellationToken ct) => new ValueTask<bool>(true));
+            var ys = xs.SkipWhileAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(true));
 
             var e = ys.GetAsyncEnumerator();
             await NoNextAsync(e);
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Cancel_Throws_Predicate()
+        public async Task SkipWhileAwaitWithCancellation_Throws_Predicate()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
+            var ys = xs.SkipWhileAwaitWithCancellation(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Cancel_Indexed()
+        public async Task SkipWhileAwaitWithCancellation_Indexed()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((x, i, ct) => new ValueTask<bool>(i < 2));
+            var ys = xs.SkipWhileAwaitWithCancellation((x, i, ct) => new ValueTask<bool>(i < 2));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 3);
@@ -370,10 +370,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Cancel_Indexed_False()
+        public async Task SkipWhileAwaitWithCancellation_Indexed_False()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((x, i, ct) => new ValueTask<bool>(false));
+            var ys = xs.SkipWhileAwaitWithCancellation((x, i, ct) => new ValueTask<bool>(false));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -384,40 +384,40 @@ namespace Tests
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Cancel_Indexed_True()
+        public async Task SkipWhileAwaitWithCancellation_Indexed_True()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((x, i, ct) => new ValueTask<bool>(true));
+            var ys = xs.SkipWhileAwaitWithCancellation((x, i, ct) => new ValueTask<bool>(true));
 
             var e = ys.GetAsyncEnumerator();
             await NoNextAsync(e);
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Cancel_Indexed_Throws_Predicate()
+        public async Task SkipWhileAwaitWithCancellation_Indexed_Throws_Predicate()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile(new Func<int, int, CancellationToken, ValueTask<bool>>((x, i, ct) => { throw ex; }));
+            var ys = xs.SkipWhileAwaitWithCancellation(new Func<int, int, CancellationToken, ValueTask<bool>>((x, i, ct) => { throw ex; }));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Cancel_SequenceIdentity()
+        public async Task SkipWhileAwaitWithCancellation_SequenceIdentity()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((int x, CancellationToken ct) => new ValueTask<bool>(x < 3));
+            var ys = xs.SkipWhileAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(x < 3));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task SkipWhile_Async_Cancel_Indexed_SequenceIdentity()
+        public async Task SkipWhileAwaitWithCancellation_Indexed_SequenceIdentity()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.SkipWhile((x, i, ct) => new ValueTask<bool>(false));
+            var ys = xs.SkipWhileAwaitWithCancellation((x, i, ct) => new ValueTask<bool>(false));
 
             await SequenceIdentity(ys);
         }

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Sum.cs

@@ -79,7 +79,7 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<decimal>), x => x, CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<decimal?>), x => x, CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, int>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, int?>), CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, long>), CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, long?>), CancellationToken.None).AsTask());
@@ -92,76 +92,76 @@ namespace Tests
 
             // Sum<T>(IAE<T>, Func<T, VT<P>>)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x)).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>)).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>)).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>)).AsTask());
 
             // Sum<T>(IAE<T>, Func<T, VT<P>>, CT)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<int>), x => new ValueTask<int>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<int?>), x => new ValueTask<int?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<long>), x => new ValueTask<long>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<long?>), x => new ValueTask<long?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<double>), x => new ValueTask<double>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<double?>), x => new ValueTask<double?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<float>), x => new ValueTask<float>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<float?>), x => new ValueTask<float?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<decimal>), x => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(default(IAsyncEnumerable<decimal?>), x => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<int?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<long?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<double?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<float?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitAsync(AsyncEnumerable.Empty<int>(), default(Func<int, ValueTask<decimal?>>), CancellationToken.None).AsTask());
 
 #if !NO_DEEP_CANCELLATION
             // Sum<T>(IAE<T>, Func<T, CT, VT<P>>, CT)
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<int>), (x, ct) => new ValueTask<int>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<int?>), (x, ct) => new ValueTask<int?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<long>), (x, ct) => new ValueTask<long>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<long?>), (x, ct) => new ValueTask<long?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<double>), (x, ct) => new ValueTask<double>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<double?>), (x, ct) => new ValueTask<double?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<float>), (x, ct) => new ValueTask<float>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<float?>), (x, ct) => new ValueTask<float?>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<decimal>), (x, ct) => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(default(IAsyncEnumerable<decimal?>), (x, ct) => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(default(IAsyncEnumerable<int>), (x, ct) => new ValueTask<int>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(default(IAsyncEnumerable<int?>), (x, ct) => new ValueTask<int?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(default(IAsyncEnumerable<long>), (x, ct) => new ValueTask<long>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(default(IAsyncEnumerable<long?>), (x, ct) => new ValueTask<long?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(default(IAsyncEnumerable<double>), (x, ct) => new ValueTask<double>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(default(IAsyncEnumerable<double?>), (x, ct) => new ValueTask<double?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(default(IAsyncEnumerable<float>), (x, ct) => new ValueTask<float>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(default(IAsyncEnumerable<float?>), (x, ct) => new ValueTask<float?>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(default(IAsyncEnumerable<decimal>), (x, ct) => new ValueTask<decimal>(x), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(default(IAsyncEnumerable<decimal?>), (x, ct) => new ValueTask<decimal?>(x), CancellationToken.None).AsTask());
 
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<int>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<int?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float?>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal>>), CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default, CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<int?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<long?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<double?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<float?>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal>>), CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.SumAwaitWithCancellationAsync(AsyncEnumerable.Empty<int>(), default(Func<int, CancellationToken, ValueTask<decimal?>>), CancellationToken.None).AsTask());
 #endif
         }
 
@@ -172,7 +172,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Sum(), await ys.SumAsync());
             Assert.Equal(xs.Sum(), await ys.SumAsync(x => x));
-            Assert.Equal(xs.Sum(), await ys.SumAsync(x => new ValueTask<int>(x)));
+            Assert.Equal(xs.Sum(), await ys.SumAwaitAsync(x => new ValueTask<int>(x)));
         }
 
         [Fact]
@@ -182,7 +182,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Sum(), await ys.SumAsync());
             Assert.Equal(xs.Sum(), await ys.SumAsync(x => x));
-            Assert.Equal(xs.Sum(), await ys.SumAsync(x => new ValueTask<int?>(x)));
+            Assert.Equal(xs.Sum(), await ys.SumAwaitAsync(x => new ValueTask<int?>(x)));
         }
 
         [Fact]
@@ -192,7 +192,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Sum(), await ys.SumAsync());
             Assert.Equal(xs.Sum(), await ys.SumAsync(x => x));
-            Assert.Equal(xs.Sum(), await ys.SumAsync(x => new ValueTask<long>(x)));
+            Assert.Equal(xs.Sum(), await ys.SumAwaitAsync(x => new ValueTask<long>(x)));
         }
 
         [Fact]
@@ -202,7 +202,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Sum(), await ys.SumAsync());
             Assert.Equal(xs.Sum(), await ys.SumAsync(x => x));
-            Assert.Equal(xs.Sum(), await ys.SumAsync(x => new ValueTask<long?>(x)));
+            Assert.Equal(xs.Sum(), await ys.SumAwaitAsync(x => new ValueTask<long?>(x)));
         }
 
         [Fact]
@@ -212,7 +212,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Sum(), await ys.SumAsync());
             Assert.Equal(xs.Sum(), await ys.SumAsync(x => x));
-            Assert.Equal(xs.Sum(), await ys.SumAsync(x => new ValueTask<double>(x)));
+            Assert.Equal(xs.Sum(), await ys.SumAwaitAsync(x => new ValueTask<double>(x)));
         }
 
         [Fact]
@@ -222,7 +222,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Sum(), await ys.SumAsync());
             Assert.Equal(xs.Sum(), await ys.SumAsync(x => x));
-            Assert.Equal(xs.Sum(), await ys.SumAsync(x => new ValueTask<double?>(x)));
+            Assert.Equal(xs.Sum(), await ys.SumAwaitAsync(x => new ValueTask<double?>(x)));
         }
 
         [Fact]
@@ -232,7 +232,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Sum(), await ys.SumAsync());
             Assert.Equal(xs.Sum(), await ys.SumAsync(x => x));
-            Assert.Equal(xs.Sum(), await ys.SumAsync(x => new ValueTask<float>(x)));
+            Assert.Equal(xs.Sum(), await ys.SumAwaitAsync(x => new ValueTask<float>(x)));
         }
 
         [Fact]
@@ -242,7 +242,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Sum(), await ys.SumAsync());
             Assert.Equal(xs.Sum(), await ys.SumAsync(x => x));
-            Assert.Equal(xs.Sum(), await ys.SumAsync(x => new ValueTask<float?>(x)));
+            Assert.Equal(xs.Sum(), await ys.SumAwaitAsync(x => new ValueTask<float?>(x)));
         }
 
         [Fact]
@@ -252,7 +252,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Sum(), await ys.SumAsync());
             Assert.Equal(xs.Sum(), await ys.SumAsync(x => x));
-            Assert.Equal(xs.Sum(), await ys.SumAsync(x => new ValueTask<decimal>(x)));
+            Assert.Equal(xs.Sum(), await ys.SumAwaitAsync(x => new ValueTask<decimal>(x)));
         }
 
         [Fact]
@@ -262,7 +262,7 @@ namespace Tests
             var ys = xs.ToAsyncEnumerable();
             Assert.Equal(xs.Sum(), await ys.SumAsync());
             Assert.Equal(xs.Sum(), await ys.SumAsync(x => x));
-            Assert.Equal(xs.Sum(), await ys.SumAsync(x => new ValueTask<decimal?>(x)));
+            Assert.Equal(xs.Sum(), await ys.SumAwaitAsync(x => new ValueTask<decimal?>(x)));
         }
     }
 }

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/TakeWhile.cs

@@ -13,7 +13,7 @@ namespace Tests
     public class TakeWhile : AsyncEnumerableTests
     {
         [Fact]
-        public void TakeWhile_Sync_Null()
+        public void TakeWhile_Null()
         {
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(default, x => true));
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(default, (x, i) => true));
@@ -22,7 +22,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Sync_Simple1()
+        public async Task TakeWhile_Simple1()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile(x => x < 3);
@@ -34,7 +34,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Sync_Simple2()
+        public async Task TakeWhile_Simple2()
         {
             var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile(x => x < 3);
@@ -46,7 +46,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Sync_False()
+        public async Task TakeWhile_False()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile(x => false);
@@ -56,7 +56,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Sync_True()
+        public async Task TakeWhile_True()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile(x => true);
@@ -70,7 +70,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Sync_Throws_Predicate()
+        public async Task TakeWhile_Throws_Predicate()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -81,7 +81,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Sync_Indexed()
+        public async Task TakeWhile_Indexed()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile((x, i) => i < 2);
@@ -93,7 +93,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Sync_Indexed_False()
+        public async Task TakeWhile_Indexed_False()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile((x, i) => false);
@@ -103,7 +103,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Sync_Indexed_True()
+        public async Task TakeWhile_Indexed_True()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile((x, i) => true);
@@ -117,7 +117,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Sync_Indexed_Throws_Predicate()
+        public async Task TakeWhile_Indexed_Throws_Predicate()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
@@ -128,7 +128,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Sync_SequenceIdentity()
+        public async Task TakeWhile_SequenceIdentity()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile(x => x < 3);
@@ -137,7 +137,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Sync_Indexed_SequenceIdentity()
+        public async Task TakeWhile_Indexed_SequenceIdentity()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
             var ys = xs.TakeWhile((x, i) => i < 2);
@@ -146,19 +146,19 @@ namespace Tests
         }
 
         [Fact]
-        public void TakeWhile_Async_Null()
+        public void TakeWhileAwait_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(default, x => new ValueTask<bool>(true)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile(default, (int x, int i) => new ValueTask<bool>(true)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile(Return42, default(Func<int, ValueTask<bool>>)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile(Return42, default(Func<int, int, ValueTask<bool>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhileAwait<int>(default, x => new ValueTask<bool>(true)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhileAwait(default, (int x, int i) => new ValueTask<bool>(true)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhileAwait(Return42, default(Func<int, ValueTask<bool>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhileAwait(Return42, default(Func<int, int, ValueTask<bool>>)));
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Simple1()
+        public async Task TakeWhileAwait_Simple1()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile(x => new ValueTask<bool>(x < 3));
+            var ys = xs.TakeWhileAwait(x => new ValueTask<bool>(x < 3));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -167,10 +167,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Simple2()
+        public async Task TakeWhileAwait_Simple2()
         {
             var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile(x => new ValueTask<bool>(x < 3));
+            var ys = xs.TakeWhileAwait(x => new ValueTask<bool>(x < 3));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -179,20 +179,20 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Async_False()
+        public async Task TakeWhileAwait_False()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile(x => new ValueTask<bool>(false));
+            var ys = xs.TakeWhileAwait(x => new ValueTask<bool>(false));
 
             var e = ys.GetAsyncEnumerator();
             await NoNextAsync(e);
         }
 
         [Fact]
-        public async Task TakeWhile_Async_True()
+        public async Task TakeWhileAwait_True()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile(x => new ValueTask<bool>(true));
+            var ys = xs.TakeWhileAwait(x => new ValueTask<bool>(true));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -203,21 +203,21 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Throws_Predicate()
+        public async Task TakeWhileAwait_Throws_Predicate()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile(new Func<int, ValueTask<bool>>(x => { throw ex; }));
+            var ys = xs.TakeWhileAwait(new Func<int, ValueTask<bool>>(x => { throw ex; }));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Indexed()
+        public async Task TakeWhileAwait_Indexed()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((x, i) => new ValueTask<bool>(i < 2));
+            var ys = xs.TakeWhileAwait((x, i) => new ValueTask<bool>(i < 2));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -226,20 +226,20 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Indexed_False()
+        public async Task TakeWhileAwait_Indexed_False()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((int x, int i) => new ValueTask<bool>(false));
+            var ys = xs.TakeWhileAwait((int x, int i) => new ValueTask<bool>(false));
 
             var e = ys.GetAsyncEnumerator();
             await NoNextAsync(e);
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Indexed_True()
+        public async Task TakeWhileAwait_Indexed_True()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((int x, int i) => new ValueTask<bool>(true));
+            var ys = xs.TakeWhileAwait((int x, int i) => new ValueTask<bool>(true));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -250,30 +250,30 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Indexed_Throws_Predicate()
+        public async Task TakeWhileAwait_Indexed_Throws_Predicate()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile(new Func<int, int, ValueTask<bool>>((x, i) => { throw ex; }));
+            var ys = xs.TakeWhileAwait(new Func<int, int, ValueTask<bool>>((x, i) => { throw ex; }));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
-        public async Task TakeWhile_Async_SequenceIdentity()
+        public async Task TakeWhileAwait_SequenceIdentity()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile(x => new ValueTask<bool>(x < 3));
+            var ys = xs.TakeWhileAwait(x => new ValueTask<bool>(x < 3));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Indexed_SequenceIdentity()
+        public async Task TakeWhileAwait_Indexed_SequenceIdentity()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((x, i) => new ValueTask<bool>(i < 2));
+            var ys = xs.TakeWhileAwait((x, i) => new ValueTask<bool>(i < 2));
 
             await SequenceIdentity(ys);
         }
@@ -281,19 +281,19 @@ namespace Tests
 #if !NO_DEEP_CANCELLATION
 
         [Fact]
-        public void TakeWhile_Async_Cancel_Null()
+        public void TakeWhileAwaitWithCancellation_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile(default, (int x, CancellationToken ct) => new ValueTask<bool>(true)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile<int>(default, (x, i, ct) => new ValueTask<bool>(true)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile(Return42, default(Func<int, CancellationToken, ValueTask<bool>>)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhile(Return42, default(Func<int, int, CancellationToken, ValueTask<bool>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhileAwaitWithCancellation(default, (int x, CancellationToken ct) => new ValueTask<bool>(true)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhileAwaitWithCancellation<int>(default, (x, i, ct) => new ValueTask<bool>(true)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhileAwaitWithCancellation(Return42, default(Func<int, CancellationToken, ValueTask<bool>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.TakeWhileAwaitWithCancellation(Return42, default(Func<int, int, CancellationToken, ValueTask<bool>>)));
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Cancel_Simple1()
+        public async Task TakeWhileAwaitWithCancellation_Simple1()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((int x, CancellationToken ct) => new ValueTask<bool>(x < 3));
+            var ys = xs.TakeWhileAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(x < 3));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -302,10 +302,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Cancel_Simple2()
+        public async Task TakeWhileAwaitWithCancellation_Simple2()
         {
             var xs = new[] { 1, 2, 3, 4, 3, 2, 1 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((int x, CancellationToken ct) => new ValueTask<bool>(x < 3));
+            var ys = xs.TakeWhileAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(x < 3));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -314,20 +314,20 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Cancel_False()
+        public async Task TakeWhileAwaitWithCancellation_False()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((int x, CancellationToken ct) => new ValueTask<bool>(false));
+            var ys = xs.TakeWhileAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(false));
 
             var e = ys.GetAsyncEnumerator();
             await NoNextAsync(e);
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Cancel_True()
+        public async Task TakeWhileAwaitWithCancellation_True()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((int x, CancellationToken ct) => new ValueTask<bool>(true));
+            var ys = xs.TakeWhileAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(true));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -338,21 +338,21 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Cancel_Throws_Predicate()
+        public async Task TakeWhileAwaitWithCancellation_Throws_Predicate()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
+            var ys = xs.TakeWhileAwaitWithCancellation(new Func<int, CancellationToken, ValueTask<bool>>((x, ct) => { throw ex; }));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Cancel_Indexed()
+        public async Task TakeWhileAwaitWithCancellation_Indexed()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((x, i, ct) => new ValueTask<bool>(i < 2));
+            var ys = xs.TakeWhileAwaitWithCancellation((x, i, ct) => new ValueTask<bool>(i < 2));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -361,20 +361,20 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Cancel_Indexed_False()
+        public async Task TakeWhileAwaitWithCancellation_Indexed_False()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((x, i, ct) => new ValueTask<bool>(false));
+            var ys = xs.TakeWhileAwaitWithCancellation((x, i, ct) => new ValueTask<bool>(false));
 
             var e = ys.GetAsyncEnumerator();
             await NoNextAsync(e);
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Cancel_Indexed_True()
+        public async Task TakeWhileAwaitWithCancellation_Indexed_True()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((x, i, ct) => new ValueTask<bool>(true));
+            var ys = xs.TakeWhileAwaitWithCancellation((x, i, ct) => new ValueTask<bool>(true));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 1);
@@ -385,30 +385,30 @@ namespace Tests
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Cancel_Indexed_Throws_Predicate()
+        public async Task TakeWhileAwaitWithCancellation_Indexed_Throws_Predicate()
         {
             var ex = new Exception("Bang");
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile(new Func<int, int, CancellationToken, ValueTask<bool>>((x, ct, i) => { throw ex; }));
+            var ys = xs.TakeWhileAwaitWithCancellation(new Func<int, int, CancellationToken, ValueTask<bool>>((x, ct, i) => { throw ex; }));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Cancel_SequenceIdentity()
+        public async Task TakeWhileAwaitWithCancellation_SequenceIdentity()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((int x, CancellationToken ct) => new ValueTask<bool>(x < 3));
+            var ys = xs.TakeWhileAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(x < 3));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task TakeWhile_Async_Cancel_Indexed_SequenceIdentity()
+        public async Task TakeWhileAwaitWithCancellation_Indexed_SequenceIdentity()
         {
             var xs = new[] { 1, 2, 3, 4 }.ToAsyncEnumerable();
-            var ys = xs.TakeWhile((x, i, ct) => new ValueTask<bool>(i < 2));
+            var ys = xs.TakeWhileAwaitWithCancellation((x, i, ct) => new ValueTask<bool>(i < 2));
 
             await SequenceIdentity(ys);
         }

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToDictionary.cs

@@ -20,7 +20,7 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionaryAsync(Return42, default(Func<int, int>)).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionaryAsync<int, int>(default, x => 0, EqualityComparer<int>.Default).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionaryAsync(Return42, default(Func<int, int>), EqualityComparer<int>.Default).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionaryAsync(Return42, default, EqualityComparer<int>.Default).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionaryAsync<int, int, int>(default, x => 0, x => 0).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionaryAsync<int, int, int>(Return42, default, x => 0).AsTask());
@@ -34,7 +34,7 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionaryAsync(Return42, default(Func<int, int>), CancellationToken.None).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionaryAsync<int, int>(default, x => 0, EqualityComparer<int>.Default, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionaryAsync(Return42, default(Func<int, int>), EqualityComparer<int>.Default, CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionaryAsync(Return42, default, EqualityComparer<int>.Default, CancellationToken.None).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionaryAsync<int, int, int>(default, x => 0, x => 0, CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToDictionaryAsync<int, int, int>(Return42, default, x => 0, CancellationToken.None).AsTask());

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToLookup.cs

@@ -21,7 +21,7 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookupAsync(Return42, default(Func<int, int>)).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookupAsync<int, int>(default, x => 0, EqualityComparer<int>.Default).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookupAsync(Return42, default(Func<int, int>), EqualityComparer<int>.Default).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookupAsync(Return42, default, EqualityComparer<int>.Default).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookupAsync<int, int, int>(default, x => 0, x => 0).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookupAsync<int, int, int>(Return42, default, x => 0).AsTask());
@@ -35,7 +35,7 @@ namespace Tests
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookupAsync(Return42, default(Func<int, int>), CancellationToken.None).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookupAsync<int, int>(default, x => 0, EqualityComparer<int>.Default, CancellationToken.None).AsTask());
-            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookupAsync(Return42, default(Func<int, int>), EqualityComparer<int>.Default, CancellationToken.None).AsTask());
+            await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookupAsync(Return42, default, EqualityComparer<int>.Default, CancellationToken.None).AsTask());
 
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookupAsync<int, int, int>(default, x => 0, x => 0, CancellationToken.None).AsTask());
             await Assert.ThrowsAsync<ArgumentNullException>(() => AsyncEnumerable.ToLookupAsync<int, int, int>(Return42, default, x => 0, CancellationToken.None).AsTask());

Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Where.cs

@@ -13,7 +13,7 @@ namespace Tests
     public class Where : AsyncEnumerableTests
     {
         [Fact]
-        public void Where_Sync_Null()
+        public void Where_Null()
         {
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where<int>(default, x => true));
             Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where<int>(default, (x, i) => true));
@@ -22,7 +22,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Sync_Simple()
+        public async Task Where_Simple()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ys = xs.Where(x => x % 2 == 0);
@@ -36,7 +36,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Sync_Indexed()
+        public async Task Where_Indexed()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ys = xs.Where((x, i) => i % 2 == 0);
@@ -51,7 +51,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Sync_Throws_Predicate()
+        public async Task Where_Throws_Predicate()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ex = new Exception("Bang");
@@ -65,7 +65,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Sync_Indexed_Throws_Predicate()
+        public async Task Where_Indexed_Throws_Predicate()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ex = new Exception("Bang");
@@ -79,7 +79,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Sync_Throws_Source()
+        public async Task Where_Throws_Source()
         {
             var ex = new Exception("Bang");
             var xs = Throw<int>(ex);
@@ -90,7 +90,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Sync_Indexed_Throws_Source()
+        public async Task Where_Indexed_Throws_Source()
         {
             var ex = new Exception("Bang");
             var xs = Throw<int>(ex);
@@ -101,7 +101,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Sync_WhereWhere()
+        public async Task Where_WhereWhere()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ys = xs.Where(x => x % 2 == 0).Where(x => x > 5);
@@ -112,7 +112,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Sync_SequenceIdentity()
+        public async Task Where_SequenceIdentity()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ys = xs.Where(x => x % 2 == 0);
@@ -121,7 +121,7 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Sync_Indexed_SequenceIdentity()
+        public async Task Where_Indexed_SequenceIdentity()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ys = xs.Where((x, i) => i % 2 == 0);
@@ -130,19 +130,19 @@ namespace Tests
         }
 
         [Fact]
-        public void Where_Async_Null()
+        public void WhereAwait_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where<int>(default, x => new ValueTask<bool>(true)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where<int>(default, (int x, int i) => new ValueTask<bool>(true)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where(Return42, default(Func<int, ValueTask<bool>>)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where(Return42, default(Func<int, int, ValueTask<bool>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.WhereAwait<int>(default, x => new ValueTask<bool>(true)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.WhereAwait<int>(default, (int x, int i) => new ValueTask<bool>(true)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.WhereAwait(Return42, default(Func<int, ValueTask<bool>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.WhereAwait(Return42, default(Func<int, int, ValueTask<bool>>)));
         }
 
         [Fact]
-        public async Task Where_Async_Simple()
+        public async Task WhereAwait_Simple()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
-            var ys = xs.Where(x => new ValueTask<bool>(x % 2 == 0));
+            var ys = xs.WhereAwait(x => new ValueTask<bool>(x % 2 == 0));
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 8);
             await HasNextAsync(e, 4);
@@ -153,10 +153,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Async_Indexed()
+        public async Task WhereAwait_Indexed()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
-            var ys = xs.Where((x, i) => new ValueTask<bool>(i % 2 == 0));
+            var ys = xs.WhereAwait((x, i) => new ValueTask<bool>(i % 2 == 0));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 8);
@@ -168,11 +168,11 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Async_Throws_Predicate()
+        public async Task WhereAwait_Throws_Predicate()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ex = new Exception("Bang");
-            var ys = xs.Where(x => { if (x == 4) throw ex; return new ValueTask<bool>(true); });
+            var ys = xs.WhereAwait(x => { if (x == 4) throw ex; return new ValueTask<bool>(true); });
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 8);
@@ -182,11 +182,11 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Async_Indexed_Throws_Predicate()
+        public async Task WhereAwait_Indexed_Throws_Predicate()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ex = new Exception("Bang");
-            var ys = xs.Where((x, i) => { if (i == 3) throw ex; return new ValueTask<bool>(true); });
+            var ys = xs.WhereAwait((x, i) => { if (i == 3) throw ex; return new ValueTask<bool>(true); });
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 8);
@@ -196,32 +196,32 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Async_Throws_Source()
+        public async Task WhereAwait_Throws_Source()
         {
             var ex = new Exception("Bang");
             var xs = Throw<int>(ex);
-            var ys = xs.Where(x => new ValueTask<bool>(true));
+            var ys = xs.WhereAwait(x => new ValueTask<bool>(true));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
-        public async Task Where_Async_Indexed_Throws_Source()
+        public async Task WhereAwait_Indexed_Throws_Source()
         {
             var ex = new Exception("Bang");
             var xs = Throw<int>(ex);
 
-            var ys = xs.Where((int x, int i) => new ValueTask<bool>(true));
+            var ys = xs.WhereAwait((int x, int i) => new ValueTask<bool>(true));
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
-        public async Task Where_Async_WhereWhere()
+        public async Task WhereAwait_WhereWhere()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
-            var ys = xs.Where(x => new ValueTask<bool>(x % 2 == 0)).Where(x => new ValueTask<bool>(x > 5));
+            var ys = xs.WhereAwait(x => new ValueTask<bool>(x % 2 == 0)).WhereAwait(x => new ValueTask<bool>(x > 5));
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 8);
             await HasNextAsync(e, 6);
@@ -229,41 +229,39 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Async_SequenceIdentity()
+        public async Task WhereAwait_SequenceIdentity()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
-            var ys = xs.Where(x => new ValueTask<bool>(x % 2 == 0));
+            var ys = xs.WhereAwait(x => new ValueTask<bool>(x % 2 == 0));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Where_Async_Indexed_SequenceIdentity()
+        public async Task WhereAwait_Indexed_SequenceIdentity()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
-            var ys = xs.Where((x, i) => new ValueTask<bool>(i % 2 == 0));
+            var ys = xs.WhereAwait((x, i) => new ValueTask<bool>(i % 2 == 0));
 
             await SequenceIdentity(ys);
         }
 
 #if !NO_DEEP_CANCELLATION
 
-        // REVIEW: These overloads are problematic for type inference. E.g. xs.Where((x, ct) => ...) is ambiguous.
-
         [Fact]
-        public void Where_Async_Cancel_Null()
+        public void WhereAwaitWithCancellation_Null()
         {
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where<int>(default, (int x, CancellationToken ct) => new ValueTask<bool>(true)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where<int>(default, (x, i, ct) => new ValueTask<bool>(true)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where(Return42, default(Func<int, CancellationToken, ValueTask<bool>>)));
-            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.Where(Return42, default(Func<int, int, CancellationToken, ValueTask<bool>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.WhereAwaitWithCancellation<int>(default, (int x, CancellationToken ct) => new ValueTask<bool>(true)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.WhereAwaitWithCancellation<int>(default, (x, i, ct) => new ValueTask<bool>(true)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.WhereAwaitWithCancellation(Return42, default(Func<int, CancellationToken, ValueTask<bool>>)));
+            Assert.Throws<ArgumentNullException>(() => AsyncEnumerable.WhereAwaitWithCancellation(Return42, default(Func<int, int, CancellationToken, ValueTask<bool>>)));
         }
 
         [Fact]
-        public async Task Where_Async_Cancel_Simple()
+        public async Task WhereAwaitWithCancellation_Simple()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
-            var ys = xs.Where((int x, CancellationToken ct) => new ValueTask<bool>(x % 2 == 0));
+            var ys = xs.WhereAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(x % 2 == 0));
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 8);
             await HasNextAsync(e, 4);
@@ -274,10 +272,10 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Async_Cancel_Indexed()
+        public async Task WhereAwaitWithCancellation_Indexed()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
-            var ys = xs.Where((x, i, ct) => new ValueTask<bool>(i % 2 == 0));
+            var ys = xs.WhereAwaitWithCancellation((x, i, ct) => new ValueTask<bool>(i % 2 == 0));
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 8);
@@ -289,11 +287,11 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Async_Cancel_Throws_Predicate()
+        public async Task WhereAwaitWithCancellation_Throws_Predicate()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ex = new Exception("Bang");
-            var ys = xs.Where((int x, CancellationToken ct) => { if (x == 4) throw ex; return new ValueTask<bool>(true); });
+            var ys = xs.WhereAwaitWithCancellation((int x, CancellationToken ct) => { if (x == 4) throw ex; return new ValueTask<bool>(true); });
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 8);
@@ -303,11 +301,11 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Async_Cancel_Indexed_Throws_Predicate()
+        public async Task WhereAwaitWithCancellation_Indexed_Throws_Predicate()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
             var ex = new Exception("Bang");
-            var ys = xs.Where((x, i, ct) => { if (i == 3) throw ex; return new ValueTask<bool>(true); });
+            var ys = xs.WhereAwaitWithCancellation((x, i, ct) => { if (i == 3) throw ex; return new ValueTask<bool>(true); });
 
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 8);
@@ -317,32 +315,32 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Async_Cancel_Throws_Source()
+        public async Task WhereAwaitWithCancellation_Throws_Source()
         {
             var ex = new Exception("Bang");
             var xs = Throw<int>(ex);
-            var ys = xs.Where((int x, CancellationToken ct) => new ValueTask<bool>(true));
+            var ys = xs.WhereAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(true));
 
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
-        public async Task Where_Async_Cancel_Indexed_Throws_Source()
+        public async Task WhereAwaitWithCancellation_Indexed_Throws_Source()
         {
             var ex = new Exception("Bang");
             var xs = Throw<int>(ex);
 
-            var ys = xs.Where((x, i, ct) => new ValueTask<bool>(true));
+            var ys = xs.WhereAwaitWithCancellation((x, i, ct) => new ValueTask<bool>(true));
             var e = ys.GetAsyncEnumerator();
             await AssertThrowsAsync(e.MoveNextAsync(), ex);
         }
 
         [Fact]
-        public async Task Where_Async_Cancel_WhereWhere()
+        public async Task WhereAwaitWithCancellation_WhereWhere()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
-            var ys = xs.Where((int x, CancellationToken ct) => new ValueTask<bool>(x % 2 == 0)).Where((int x, CancellationToken ct) => new ValueTask<bool>(x > 5));
+            var ys = xs.WhereAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(x % 2 == 0)).WhereAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(x > 5));
             var e = ys.GetAsyncEnumerator();
             await HasNextAsync(e, 8);
             await HasNextAsync(e, 6);
@@ -350,19 +348,19 @@ namespace Tests
         }
 
         [Fact]
-        public async Task Where_Async_Cancel_SequenceIdentity()
+        public async Task WhereAwaitWithCancellation_SequenceIdentity()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
-            var ys = xs.Where((int x, CancellationToken ct) => new ValueTask<bool>(x % 2 == 0));
+            var ys = xs.WhereAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask<bool>(x % 2 == 0));
 
             await SequenceIdentity(ys);
         }
 
         [Fact]
-        public async Task Where_Async_Cancel_Indexed_SequenceIdentity()
+        public async Task WhereAwaitWithCancellation_Indexed_SequenceIdentity()
         {
             var xs = new[] { 8, 5, 7, 4, 6, 9, 2, 1, 0 }.ToAsyncEnumerable();
-            var ys = xs.Where((x, i, ct) => new ValueTask<bool>(i % 2 == 0));
+            var ys = xs.WhereAwaitWithCancellation((x, i, ct) => new ValueTask<bool>(i % 2 == 0));
 
             await SequenceIdentity(ys);
         }

Ix.NET/Source/System.Linq.Async/System.Linq.Async.csproj

@@ -73,4 +73,8 @@
     </None>
   </ItemGroup>
 
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+
 </Project>

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Aggregate.cs

@@ -40,7 +40,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<TSource> AggregateAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, TSource, ValueTask<TSource>> accumulator, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> AggregateAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, TSource, ValueTask<TSource>> accumulator, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -71,7 +71,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<TSource> AggregateAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, TSource, CancellationToken, ValueTask<TSource>> accumulator, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> AggregateAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, TSource, CancellationToken, ValueTask<TSource>> accumulator, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -124,7 +124,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<TAccumulate> AggregateAsync<TSource, TAccumulate>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, ValueTask<TAccumulate>> accumulator, CancellationToken cancellationToken = default)
+        public static ValueTask<TAccumulate> AggregateAwaitAsync<TSource, TAccumulate>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, ValueTask<TAccumulate>> accumulator, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -147,7 +147,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<TAccumulate> AggregateAsync<TSource, TAccumulate>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, ValueTask<TAccumulate>> accumulator, CancellationToken cancellationToken = default)
+        public static ValueTask<TAccumulate> AggregateAwaitWithCancellationAsync<TSource, TAccumulate>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, ValueTask<TAccumulate>> accumulator, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -194,7 +194,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<TResult> AggregateAsync<TSource, TAccumulate, TResult>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, ValueTask<TAccumulate>> accumulator, Func<TAccumulate, ValueTask<TResult>> resultSelector, CancellationToken cancellationToken = default)
+        public static ValueTask<TResult> AggregateAwaitAsync<TSource, TAccumulate, TResult>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, ValueTask<TAccumulate>> accumulator, Func<TAccumulate, ValueTask<TResult>> resultSelector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -219,7 +219,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<TResult> AggregateAsync<TSource, TAccumulate, TResult>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, ValueTask<TAccumulate>> accumulator, Func<TAccumulate, CancellationToken, ValueTask<TResult>> resultSelector, CancellationToken cancellationToken = default)
+        public static ValueTask<TResult> AggregateAwaitWithCancellationAsync<TSource, TAccumulate, TResult>(this IAsyncEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, CancellationToken, ValueTask<TAccumulate>> accumulator, Func<TAccumulate, CancellationToken, ValueTask<TResult>> resultSelector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/All.cs

@@ -33,7 +33,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<bool> AllAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<bool> AllAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -57,7 +57,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<bool> AllAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<bool> AllAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Any.cs

@@ -49,7 +49,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<bool> AnyAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<bool> AnyAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -73,7 +73,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<bool> AnyAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<bool> AnyAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.cs

@@ -76,7 +76,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<double> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double> AverageAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -111,7 +111,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<double> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -212,7 +212,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<double> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double> AverageAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -247,7 +247,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<double> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -348,7 +348,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<float> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float> AverageAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -383,7 +383,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<float> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float> AverageAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -484,7 +484,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<double> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double> AverageAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -519,7 +519,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<double> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double> AverageAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -620,7 +620,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<decimal> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal> AverageAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -655,7 +655,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<decimal> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal> AverageAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -772,7 +772,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> AverageAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -815,7 +815,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -940,7 +940,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> AverageAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -983,7 +983,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1108,7 +1108,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<float?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float?> AverageAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1151,7 +1151,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<float?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float?> AverageAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1276,7 +1276,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> AverageAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1319,7 +1319,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<double?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> AverageAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1444,7 +1444,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<decimal?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal?> AverageAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1487,7 +1487,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<decimal?> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal?> AverageAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Average.Generated.tt

@@ -191,7 +191,7 @@ else
             }
         }
 
-        public static ValueTask<<#=o.res#>> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<<#=o.res#>> AverageAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -266,7 +266,7 @@ else
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<<#=o.res#>> AverageAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<<#=o.res#>> AverageAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Count.cs

@@ -72,7 +72,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<int> CountAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<int> CountAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -101,7 +101,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<int> CountAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<int> CountAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/First.cs

@@ -42,7 +42,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<TSource> FirstAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> FirstAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -60,7 +60,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<TSource> FirstAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> FirstAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/FirstOrDefault.cs

@@ -42,7 +42,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<TSource> FirstOrDefaultAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> FirstOrDefaultAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -60,7 +60,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<TSource> FirstOrDefaultAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> FirstOrDefaultAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ForEach.cs

@@ -55,7 +55,7 @@ namespace System.Linq
             }
         }
 
-        public static Task ForEachAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, Task> action, CancellationToken cancellationToken = default)
+        public static Task ForEachAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, Task> action, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -73,7 +73,7 @@ namespace System.Linq
             }
         }
 
-        public static Task ForEachAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, Task> action, CancellationToken cancellationToken)
+        public static Task ForEachAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, Task> action, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -91,7 +91,7 @@ namespace System.Linq
             }
         }
 
-        public static Task ForEachAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, Task> action, CancellationToken cancellationToken = default)
+        public static Task ForEachAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, Task> action, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -111,7 +111,7 @@ namespace System.Linq
             }
         }
 
-        public static Task ForEachAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, Task> action, CancellationToken cancellationToken)
+        public static Task ForEachAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, Task> action, CancellationToken cancellationToken)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupBy.cs

@@ -16,17 +16,17 @@ namespace System.Linq
         public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer) =>
             new GroupedAsyncEnumerable<TSource, TKey>(source, keySelector, comparer);
 
-        public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector) =>
+        public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector) =>
             new GroupedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer: null);
 
-        public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer) =>
+        public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwait<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer) =>
             new GroupedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer);
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector) =>
+        public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector) =>
             new GroupedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer: null);
 
-        public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer) =>
+        public static IAsyncEnumerable<IAsyncGrouping<TKey, TSource>> GroupByAwaitWithCancellation<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer) =>
             new GroupedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer);
 #endif
 
@@ -36,17 +36,17 @@ namespace System.Linq
         public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer) =>
             new GroupedAsyncEnumerable<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
 
-        public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector) =>
+        public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector) =>
             new GroupedAsyncEnumerableWithTask<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer: null);
 
-        public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer) =>
+        public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwait<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer) =>
             new GroupedAsyncEnumerableWithTask<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector) =>
+        public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector) =>
             new GroupedAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer: null);
 
-        public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer) =>
+        public static IAsyncEnumerable<IAsyncGrouping<TKey, TElement>> GroupByAwaitWithCancellation<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer) =>
             new GroupedAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer);
 #endif
 
@@ -56,17 +56,17 @@ namespace System.Linq
         public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IAsyncEnumerable<TSource>, TResult> resultSelector, IEqualityComparer<TKey> comparer) =>
             new GroupedResultAsyncEnumerable<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer);
 
-        public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, ValueTask<TResult>> resultSelector) =>
+        public static IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, ValueTask<TResult>> resultSelector) =>
             new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer: null);
 
-        public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer) =>
+        public static IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer) =>
             new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer);
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, CancellationToken, ValueTask<TResult>> resultSelector) =>
+        public static IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, CancellationToken, ValueTask<TResult>> resultSelector) =>
             new GroupedResultAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer: null);
 
-        public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer) =>
+        public static IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TKey, IAsyncEnumerable<TSource>, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer) =>
             new GroupedResultAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TResult>(source, keySelector, resultSelector, comparer);
 #endif
 
@@ -76,17 +76,17 @@ namespace System.Linq
         public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, TResult> resultSelector, IEqualityComparer<TKey> comparer) =>
             new GroupedResultAsyncEnumerable<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
 
-        public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, ValueTask<TResult>> resultSelector) =>
+        public static IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, ValueTask<TResult>> resultSelector) =>
             new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer: null);
 
-        public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer) =>
+        public static IAsyncEnumerable<TResult> GroupByAwait<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer) =>
             new GroupedResultAsyncEnumerableWithTask<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, CancellationToken, ValueTask<TResult>> resultSelector) =>
+        public static IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, CancellationToken, ValueTask<TResult>> resultSelector) =>
             new GroupedResultAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer: null);
 
-        public static IAsyncEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer) =>
+        public static IAsyncEnumerable<TResult> GroupByAwaitWithCancellation<TSource, TKey, TElement, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, Func<TKey, IAsyncEnumerable<TElement>, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer) =>
             new GroupedResultAsyncEnumerableWithTaskAndCancellation<TSource, TKey, TElement, TResult>(source, keySelector, elementSelector, resultSelector, comparer);
 #endif
 
@@ -220,7 +220,7 @@ namespace System.Linq
                 {
                     case AsyncIteratorState.Allocated:
                         _lookup = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, _cancellationToken).ConfigureAwait(false);
-                        _enumerator = _lookup.Select(async g => await _resultSelector(g.Key, g).ConfigureAwait(false)).GetAsyncEnumerator(_cancellationToken); // REVIEW: Introduce another ApplyResultSelector?
+                        _enumerator = _lookup.SelectAwait(async g => await _resultSelector(g.Key, g).ConfigureAwait(false)).GetAsyncEnumerator(_cancellationToken); // REVIEW: Introduce another ApplyResultSelector?
                         _state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
@@ -310,7 +310,7 @@ namespace System.Linq
                 {
                     case AsyncIteratorState.Allocated:
                         _lookup = await Internal.LookupWithTask<TKey, TSource>.CreateAsync(_source, _keySelector, _comparer, _cancellationToken).ConfigureAwait(false);
-                        _enumerator = _lookup.Select(async g => await _resultSelector(g.Key, g, _cancellationToken).ConfigureAwait(false)).GetAsyncEnumerator(_cancellationToken); // REVIEW: Introduce another ApplyResultSelector?
+                        _enumerator = _lookup.SelectAwait(async g => await _resultSelector(g.Key, g, _cancellationToken).ConfigureAwait(false)).GetAsyncEnumerator(_cancellationToken); // REVIEW: Introduce another ApplyResultSelector?
                         _state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
@@ -493,7 +493,7 @@ namespace System.Linq
                 {
                     case AsyncIteratorState.Allocated:
                         _lookup = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, _cancellationToken).ConfigureAwait(false);
-                        _enumerator = _lookup.Select(async g => await _resultSelector(g.Key, g).ConfigureAwait(false)).GetAsyncEnumerator(_cancellationToken); // REVIEW: Introduce another ApplyResultSelector?
+                        _enumerator = _lookup.SelectAwait(async g => await _resultSelector(g.Key, g).ConfigureAwait(false)).GetAsyncEnumerator(_cancellationToken); // REVIEW: Introduce another ApplyResultSelector?
                         _state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 
@@ -585,7 +585,7 @@ namespace System.Linq
                 {
                     case AsyncIteratorState.Allocated:
                         _lookup = await Internal.LookupWithTask<TKey, TElement>.CreateAsync(_source, _keySelector, _elementSelector, _comparer, _cancellationToken).ConfigureAwait(false);
-                        _enumerator = _lookup.Select(async g => await _resultSelector(g.Key, g, _cancellationToken).ConfigureAwait(false)).GetAsyncEnumerator(_cancellationToken); // REVIEW: Introduce another ApplyResultSelector?
+                        _enumerator = _lookup.SelectAwait(async g => await _resultSelector(g.Key, g, _cancellationToken).ConfigureAwait(false)).GetAsyncEnumerator(_cancellationToken); // REVIEW: Introduce another ApplyResultSelector?
                         _state = AsyncIteratorState.Iterating;
                         goto case AsyncIteratorState.Iterating;
 

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/GroupJoin.cs

@@ -52,10 +52,10 @@ namespace System.Linq
 #endif
         }
 
-        public static IAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, ValueTask<TKey>> outerKeySelector, Func<TInner, ValueTask<TKey>> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, ValueTask<TResult>> resultSelector) =>
-            GroupJoin<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);
+        public static IAsyncEnumerable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, ValueTask<TKey>> outerKeySelector, Func<TInner, ValueTask<TKey>> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, ValueTask<TResult>> resultSelector) =>
+            GroupJoinAwait<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);
 
-        public static IAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, ValueTask<TKey>> outerKeySelector, Func<TInner, ValueTask<TKey>> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
+        public static IAsyncEnumerable<TResult> GroupJoinAwait<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, ValueTask<TKey>> outerKeySelector, Func<TInner, ValueTask<TKey>> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
         {
             if (outer == null)
                 throw Error.ArgumentNull(nameof(outer));
@@ -95,10 +95,10 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, ValueTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, ValueTask<TKey>> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, CancellationToken, ValueTask<TResult>> resultSelector) =>
-            GroupJoin<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);
+        public static IAsyncEnumerable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, ValueTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, ValueTask<TKey>> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, CancellationToken, ValueTask<TResult>> resultSelector) =>
+            GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);
 
-        public static IAsyncEnumerable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, ValueTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, ValueTask<TKey>> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
+        public static IAsyncEnumerable<TResult> GroupJoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, ValueTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, ValueTask<TKey>> innerKeySelector, Func<TOuter, IAsyncEnumerable<TInner>, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
         {
             if (outer == null)
                 throw Error.ArgumentNull(nameof(outer));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Join.cs

@@ -69,10 +69,10 @@ namespace System.Linq
 #endif
         }
 
-        public static IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, ValueTask<TKey>> outerKeySelector, Func<TInner, ValueTask<TKey>> innerKeySelector, Func<TOuter, TInner, ValueTask<TResult>> resultSelector) =>
-            Join<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);
+        public static IAsyncEnumerable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, ValueTask<TKey>> outerKeySelector, Func<TInner, ValueTask<TKey>> innerKeySelector, Func<TOuter, TInner, ValueTask<TResult>> resultSelector) =>
+            JoinAwait<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);
 
-        public static IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, ValueTask<TKey>> outerKeySelector, Func<TInner, ValueTask<TKey>> innerKeySelector, Func<TOuter, TInner, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
+        public static IAsyncEnumerable<TResult> JoinAwait<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, ValueTask<TKey>> outerKeySelector, Func<TInner, ValueTask<TKey>> innerKeySelector, Func<TOuter, TInner, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
         {
             if (outer == null)
                 throw Error.ArgumentNull(nameof(outer));
@@ -128,10 +128,10 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, ValueTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, ValueTask<TKey>> innerKeySelector, Func<TOuter, TInner, CancellationToken, ValueTask<TResult>> resultSelector) =>
-            Join<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);
+        public static IAsyncEnumerable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, ValueTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, ValueTask<TKey>> innerKeySelector, Func<TOuter, TInner, CancellationToken, ValueTask<TResult>> resultSelector) =>
+            JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer: null);
 
-        public static IAsyncEnumerable<TResult> Join<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, ValueTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, ValueTask<TKey>> innerKeySelector, Func<TOuter, TInner, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
+        public static IAsyncEnumerable<TResult> JoinAwaitWithCancellation<TOuter, TInner, TKey, TResult>(this IAsyncEnumerable<TOuter> outer, IAsyncEnumerable<TInner> inner, Func<TOuter, CancellationToken, ValueTask<TKey>> outerKeySelector, Func<TInner, CancellationToken, ValueTask<TKey>> innerKeySelector, Func<TOuter, TInner, CancellationToken, ValueTask<TResult>> resultSelector, IEqualityComparer<TKey> comparer)
         {
             if (outer == null)
                 throw Error.ArgumentNull(nameof(outer));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Last.cs

@@ -42,7 +42,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<TSource> LastAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> LastAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -60,7 +60,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<TSource> LastAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> LastAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/LastOrDefault.cs

@@ -42,7 +42,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<TSource> LastOrDefaultAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> LastOrDefaultAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -60,7 +60,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<TSource> LastOrDefaultAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> LastOrDefaultAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/LongCount.cs

@@ -61,7 +61,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<long> LongCountAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<long> LongCountAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -90,7 +90,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<long> LongCountAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<long> LongCountAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Max.cs

@@ -164,7 +164,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<TResult> MaxAsync<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TResult>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<TResult> MaxAwaitAsync<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TResult>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -244,7 +244,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<TResult> MaxAsync<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TResult>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<TResult> MaxAwaitWithCancellationAsync<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TResult>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Min.cs

@@ -166,7 +166,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<TResult> MinAsync<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TResult>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<TResult> MinAwaitAsync<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TResult>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -246,7 +246,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<TResult> MinAsync<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TResult>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<TResult> MinAwaitWithCancellationAsync<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TResult>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.cs

@@ -80,7 +80,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<int> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<int> MaxAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -117,7 +117,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<int> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<int> MaxAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -302,7 +302,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<int?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<int?> MaxAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -378,7 +378,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<int?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<int?> MaxAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -524,7 +524,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<long> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<long> MaxAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -561,7 +561,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<long> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<long> MaxAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -746,7 +746,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<long?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<long?> MaxAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -822,7 +822,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<long?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<long?> MaxAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -998,7 +998,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<float> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float> MaxAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1050,7 +1050,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<float> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float> MaxAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1242,7 +1242,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<float?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float?> MaxAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1314,7 +1314,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<float?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float?> MaxAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1486,7 +1486,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<double> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double> MaxAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1538,7 +1538,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<double> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double> MaxAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1730,7 +1730,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<double?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> MaxAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1802,7 +1802,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<double?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> MaxAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1944,7 +1944,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<decimal> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal> MaxAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -1981,7 +1981,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<decimal> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal> MaxAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -2114,7 +2114,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<decimal?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal?> MaxAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -2164,7 +2164,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<decimal?> MaxAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal?> MaxAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -2284,7 +2284,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<int> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<int> MinAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -2321,7 +2321,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<int> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<int> MinAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -2458,7 +2458,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<int?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<int?> MinAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -2510,7 +2510,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<int?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<int?> MinAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -2632,7 +2632,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<long> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<long> MinAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -2669,7 +2669,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<long> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<long> MinAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -2806,7 +2806,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<long?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<long?> MinAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -2858,7 +2858,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<long?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<long?> MinAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -3012,7 +3012,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<float> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float> MinAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -3065,7 +3065,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<float> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float> MinAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -3250,7 +3250,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<float?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float?> MinAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -3318,7 +3318,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<float?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float?> MinAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -3488,7 +3488,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<double> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double> MinAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -3541,7 +3541,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<double> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double> MinAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -3726,7 +3726,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<double?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> MinAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -3794,7 +3794,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<double?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> MinAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -3932,7 +3932,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<decimal> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal> MinAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -3969,7 +3969,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<decimal> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal> MinAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -4102,7 +4102,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<decimal?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal?> MinAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -4152,7 +4152,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<decimal?> MinAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal?> MinAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/MinMax.Generated.tt

@@ -285,15 +285,17 @@ foreach (var overload in new[] {
 })
 {
     var isDeepCancellation = overload.selector.Contains("CancellationToken");
+    var suffix = overload.invoke.StartsWith("await") ? "Await" : "";
 
     if (isDeepCancellation)
     {
+        suffix += "WithCancellation";
 #>
 #if !NO_DEEP_CANCELLATION
 <#
     }
 #>
-        public static ValueTask<<#=t#>> <#=m#>Async<TSource>(this IAsyncEnumerable<TSource> source, <#=overload.selector#> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<<#=t#>> <#=m#><#=suffix#>Async<TSource>(this IAsyncEnumerable<TSource> source, <#=overload.selector#> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderBy.cs

@@ -13,44 +13,44 @@ namespace System.Linq
         public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector) =>
             new OrderedAsyncEnumerable<TSource, TKey>(source, keySelector, comparer: null, descending: false, parent: null);
 
-        public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector) =>
+        public static IOrderedAsyncEnumerable<TSource> OrderByAwait<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector) =>
             new OrderedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer: null, descending: false, parent: null);
 
 #if !NO_DEEP_CANCELLATION
-        public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector) =>
+        public static IOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector) =>
             new OrderedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer: null, descending: false, parent: null);
 #endif
 
         public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) =>
             new OrderedAsyncEnumerable<TSource, TKey>(source, keySelector, comparer, descending: false, parent: null);
 
-        public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer) =>
+        public static IOrderedAsyncEnumerable<TSource> OrderByAwait<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer) =>
             new OrderedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer, descending: false, parent: null);
 
 #if !NO_DEEP_CANCELLATION
-        public static IOrderedAsyncEnumerable<TSource> OrderBy<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey> comparer) =>
+        public static IOrderedAsyncEnumerable<TSource> OrderByAwaitWithCancellation<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey> comparer) =>
             new OrderedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer, descending: false, parent: null);
 #endif
 
         public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector) =>
             new OrderedAsyncEnumerable<TSource, TKey>(source, keySelector, comparer: null, descending: true, parent: null);
 
-        public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector) =>
+        public static IOrderedAsyncEnumerable<TSource> OrderByDescendingAwait<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector) =>
             new OrderedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer: null, descending: true, parent: null);
 
 #if !NO_DEEP_CANCELLATION
-        public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector) =>
+        public static IOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector) =>
             new OrderedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer: null, descending: true, parent: null);
 #endif
 
         public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, TKey> keySelector, IComparer<TKey> comparer) =>
             new OrderedAsyncEnumerable<TSource, TKey>(source, keySelector, comparer, descending: true, parent: null);
 
-        public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer) =>
+        public static IOrderedAsyncEnumerable<TSource> OrderByDescendingAwait<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer) =>
             new OrderedAsyncEnumerableWithTask<TSource, TKey>(source, keySelector, comparer, descending: true, parent: null);
 
 #if !NO_DEEP_CANCELLATION
-        public static IOrderedAsyncEnumerable<TSource> OrderByDescending<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey> comparer) =>
+        public static IOrderedAsyncEnumerable<TSource> OrderByDescendingAwaitWithCancellation<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey> comparer) =>
             new OrderedAsyncEnumerableWithTaskAndCancellation<TSource, TKey>(source, keySelector, comparer, descending: true, parent: null);
 #endif
 
@@ -62,7 +62,7 @@ namespace System.Linq
             return source.CreateOrderedEnumerable(keySelector, comparer: null, descending: false);
         }
 
-        public static IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector)
+        public static IOrderedAsyncEnumerable<TSource> ThenByAwait<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -71,7 +71,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector)
+        public static IOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -88,7 +88,7 @@ namespace System.Linq
             return source.CreateOrderedEnumerable(keySelector, comparer, descending: false);
         }
 
-        public static IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
+        public static IOrderedAsyncEnumerable<TSource> ThenByAwait<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -97,7 +97,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IOrderedAsyncEnumerable<TSource> ThenBy<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
+        public static IOrderedAsyncEnumerable<TSource> ThenByAwaitWithCancellation<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -114,7 +114,7 @@ namespace System.Linq
             return source.CreateOrderedEnumerable(keySelector, comparer: null, descending: true);
         }
 
-        public static IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector)
+        public static IOrderedAsyncEnumerable<TSource> ThenByDescendingAwait<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -123,7 +123,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector)
+        public static IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -140,7 +140,7 @@ namespace System.Linq
             return source.CreateOrderedEnumerable(keySelector, comparer, descending: true);
         }
 
-        public static IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
+        public static IOrderedAsyncEnumerable<TSource> ThenByDescendingAwait<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -149,7 +149,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IOrderedAsyncEnumerable<TSource> ThenByDescending<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
+        public static IOrderedAsyncEnumerable<TSource> ThenByDescendingAwaitWithCancellation<TSource, TKey>(this IOrderedAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IComparer<TKey> comparer)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Select.cs

@@ -58,7 +58,7 @@ namespace System.Linq
 #endif
         }
 
-        public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TResult>> selector)
+        public static IAsyncEnumerable<TResult> SelectAwait<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TResult>> selector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -77,7 +77,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TResult>> selector)
+        public static IAsyncEnumerable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TResult>> selector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -96,7 +96,7 @@ namespace System.Linq
         }
 #endif
 
-        public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<TResult>> selector)
+        public static IAsyncEnumerable<TResult> SelectAwait<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<TResult>> selector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -126,7 +126,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TResult> Select<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<TResult>> selector)
+        public static IAsyncEnumerable<TResult> SelectAwaitWithCancellation<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<TResult>> selector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SelectMany.cs

@@ -23,7 +23,7 @@ namespace System.Linq
 
         // REVIEW: Should we keep these overloads that return ValueTask<IAsyncEnumerable<TResult>>? One could argue the selector is async twice.
 
-        public static IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<IAsyncEnumerable<TResult>>> selector)
+        public static IAsyncEnumerable<TResult> SelectManyAwait<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<IAsyncEnumerable<TResult>>> selector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -34,7 +34,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<IAsyncEnumerable<TResult>>> selector)
+        public static IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<IAsyncEnumerable<TResult>>> selector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -79,7 +79,7 @@ namespace System.Linq
 #endif
         }
 
-        public static IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<IAsyncEnumerable<TResult>>> selector)
+        public static IAsyncEnumerable<TResult> SelectManyAwait<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<IAsyncEnumerable<TResult>>> selector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -114,7 +114,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TResult> SelectMany<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<IAsyncEnumerable<TResult>>> selector)
+        public static IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<IAsyncEnumerable<TResult>>> selector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -178,7 +178,7 @@ namespace System.Linq
 #endif
         }
 
-        public static IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<IAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, ValueTask<TResult>> resultSelector)
+        public static IAsyncEnumerable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<IAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, ValueTask<TResult>> resultSelector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -208,7 +208,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<IAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, CancellationToken, ValueTask<TResult>> resultSelector)
+        public static IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<IAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, CancellationToken, ValueTask<TResult>> resultSelector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -274,7 +274,7 @@ namespace System.Linq
 #endif
         }
 
-        public static IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<IAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, ValueTask<TResult>> resultSelector)
+        public static IAsyncEnumerable<TResult> SelectManyAwait<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<IAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, ValueTask<TResult>> resultSelector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -311,7 +311,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<IAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, CancellationToken, ValueTask<TResult>> resultSelector)
+        public static IAsyncEnumerable<TResult> SelectManyAwaitWithCancellation<TSource, TCollection, TResult>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<IAsyncEnumerable<TCollection>>> collectionSelector, Func<TSource, TCollection, CancellationToken, ValueTask<TResult>> resultSelector)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Single.cs

@@ -85,7 +85,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<TSource> SingleAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> SingleAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -122,7 +122,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<TSource> SingleAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> SingleAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SingleOrDefault.cs

@@ -85,7 +85,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<TSource> SingleOrDefaultAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> SingleOrDefaultAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -122,7 +122,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<TSource> SingleOrDefaultAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
+        public static ValueTask<TSource> SingleOrDefaultAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SkipWhile.cs

@@ -92,7 +92,7 @@ namespace System.Linq
 #endif
         }
 
-        public static IAsyncEnumerable<TSource> SkipWhile<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
+        public static IAsyncEnumerable<TSource> SkipWhileAwait<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -130,7 +130,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TSource> SkipWhile<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate)
+        public static IAsyncEnumerable<TSource> SkipWhileAwaitWithCancellation<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -168,7 +168,7 @@ namespace System.Linq
         }
 #endif
 
-        public static IAsyncEnumerable<TSource> SkipWhile<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<bool>> predicate)
+        public static IAsyncEnumerable<TSource> SkipWhileAwait<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<bool>> predicate)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -213,7 +213,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TSource> SkipWhile<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<bool>> predicate)
+        public static IAsyncEnumerable<TSource> SkipWhileAwaitWithCancellation<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<bool>> predicate)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.cs

@@ -60,7 +60,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<int> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<int> SumAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -88,7 +88,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<int> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<int> SumAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -166,7 +166,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<long> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<long> SumAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -194,7 +194,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<long> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<long> SumAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -266,7 +266,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<float> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float> SumAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -291,7 +291,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<float> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float> SumAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -360,7 +360,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<double> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double> SumAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -385,7 +385,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<double> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double> SumAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -454,7 +454,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<decimal> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal> SumAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -479,7 +479,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<decimal> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal> SumAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -554,7 +554,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<int?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<int?> SumAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -582,7 +582,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<int?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<int?> SumAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<int?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -660,7 +660,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<long?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<long?> SumAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -688,7 +688,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<long?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<long?> SumAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<long?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -760,7 +760,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<float?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float?> SumAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -785,7 +785,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<float?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<float?> SumAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<float?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -854,7 +854,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<double?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> SumAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -879,7 +879,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<double?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<double?> SumAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<double?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -948,7 +948,7 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<decimal?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal?> SumAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -973,7 +973,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<decimal?> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<decimal?> SumAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<decimal?>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Sum.Generated.tt

@@ -111,7 +111,7 @@ else
             }
         }
 
-        public static ValueTask<<#=o.type#>> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<<#=o.type#>> SumAwaitAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -152,7 +152,7 @@ else
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<<#=o.type#>> SumAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
+        public static ValueTask<<#=o.type#>> SumAwaitWithCancellationAsync<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<<#=o.type#>>> selector, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/TakeWhile.cs

@@ -72,7 +72,7 @@ namespace System.Linq
 #endif
         }
 
-        public static IAsyncEnumerable<TSource> TakeWhile<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
+        public static IAsyncEnumerable<TSource> TakeWhileAwait<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -100,7 +100,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TSource> TakeWhile<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate)
+        public static IAsyncEnumerable<TSource> TakeWhileAwaitWithCancellation<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -128,7 +128,7 @@ namespace System.Linq
         }
 #endif
 
-        public static IAsyncEnumerable<TSource> TakeWhile<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<bool>> predicate)
+        public static IAsyncEnumerable<TSource> TakeWhileAwait<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<bool>> predicate)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -163,7 +163,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TSource> TakeWhile<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<bool>> predicate)
+        public static IAsyncEnumerable<TSource> TakeWhileAwaitWithCancellation<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<bool>> predicate)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToDictionary.cs

@@ -37,10 +37,10 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, CancellationToken cancellationToken = default) =>
-            ToDictionaryAsync<TSource, TKey>(source, keySelector, comparer: null, cancellationToken);
+        public static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, CancellationToken cancellationToken = default) =>
+            ToDictionaryAwaitAsync<TSource, TKey>(source, keySelector, comparer: null, cancellationToken);
 
-        public static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
+        public static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAwaitAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -65,10 +65,10 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, CancellationToken cancellationToken = default) =>
-            ToDictionaryAsync(source, keySelector, comparer: null, cancellationToken);
+        public static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, CancellationToken cancellationToken = default) =>
+            ToDictionaryAwaitWithCancellationAsync(source, keySelector, comparer: null, cancellationToken);
 
-        public static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
+        public static ValueTask<Dictionary<TKey, TSource>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -123,10 +123,10 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, CancellationToken cancellationToken = default) =>
-            ToDictionaryAsync<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer: null, cancellationToken);
+        public static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, CancellationToken cancellationToken = default) =>
+            ToDictionaryAwaitAsync<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer: null, cancellationToken);
 
-        public static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
+        public static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAwaitAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -154,10 +154,10 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, CancellationToken cancellationToken = default) =>
-            ToDictionaryAsync(source, keySelector, elementSelector, comparer: null, cancellationToken);
+        public static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, CancellationToken cancellationToken = default) =>
+            ToDictionaryAwaitWithCancellationAsync(source, keySelector, elementSelector, comparer: null, cancellationToken);
 
-        public static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
+        public static ValueTask<Dictionary<TKey, TElement>> ToDictionaryAwaitWithCancellationAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToLookup.cs

@@ -28,10 +28,10 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, CancellationToken cancellationToken = default) =>
-            ToLookupAsync<TSource, TKey>(source, keySelector, comparer:null, cancellationToken);
+        public static ValueTask<ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, CancellationToken cancellationToken = default) =>
+            ToLookupAwaitAsync<TSource, TKey>(source, keySelector, comparer:null, cancellationToken);
 
-        public static ValueTask<ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
+        public static ValueTask<ILookup<TKey, TSource>> ToLookupAwaitAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -47,10 +47,10 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, CancellationToken cancellationToken = default) =>
-            ToLookupAsync(source, keySelector, comparer: null, cancellationToken);
+        public static ValueTask<ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, CancellationToken cancellationToken = default) =>
+            ToLookupAwaitWithCancellationAsync(source, keySelector, comparer: null, cancellationToken);
 
-        public static ValueTask<ILookup<TKey, TSource>> ToLookupAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
+        public static ValueTask<ILookup<TKey, TSource>> ToLookupAwaitWithCancellationAsync<TSource, TKey>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -86,10 +86,10 @@ namespace System.Linq
             }
         }
 
-        public static ValueTask<ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, CancellationToken cancellationToken = default) =>
-            ToLookupAsync<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer: null, cancellationToken);
+        public static ValueTask<ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, CancellationToken cancellationToken = default) =>
+            ToLookupAwaitAsync<TSource, TKey, TElement>(source, keySelector, elementSelector, comparer: null, cancellationToken);
 
-        public static ValueTask<ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
+        public static ValueTask<ILookup<TKey, TElement>> ToLookupAwaitAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<TKey>> keySelector, Func<TSource, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -107,10 +107,10 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static ValueTask<ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, CancellationToken cancellationToken = default) =>
-            ToLookupAsync(source, keySelector, elementSelector, comparer: null, cancellationToken);
+        public static ValueTask<ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, CancellationToken cancellationToken = default) =>
+            ToLookupAwaitWithCancellationAsync(source, keySelector, elementSelector, comparer: null, cancellationToken);
 
-        public static ValueTask<ILookup<TKey, TElement>> ToLookupAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
+        public static ValueTask<ILookup<TKey, TElement>> ToLookupAwaitWithCancellationAsync<TSource, TKey, TElement>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<TKey>> keySelector, Func<TSource, CancellationToken, ValueTask<TElement>> elementSelector, IEqualityComparer<TKey> comparer, CancellationToken cancellationToken = default)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Where.cs

@@ -59,7 +59,7 @@ namespace System.Linq
 #endif
         }
 
-        public static IAsyncEnumerable<TSource> Where<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
+        public static IAsyncEnumerable<TSource> WhereAwait<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, ValueTask<bool>> predicate)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -76,7 +76,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TSource> Where<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate)
+        public static IAsyncEnumerable<TSource> WhereAwaitWithCancellation<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, CancellationToken, ValueTask<bool>> predicate)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -93,7 +93,7 @@ namespace System.Linq
         }
 #endif
 
-        public static IAsyncEnumerable<TSource> Where<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<bool>> predicate)
+        public static IAsyncEnumerable<TSource> WhereAwait<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, ValueTask<bool>> predicate)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));
@@ -126,7 +126,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TSource> Where<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<bool>> predicate)
+        public static IAsyncEnumerable<TSource> WhereAwaitWithCancellation<TSource>(this IAsyncEnumerable<TSource> source, Func<TSource, int, CancellationToken, ValueTask<bool>> predicate)
         {
             if (source == null)
                 throw Error.ArgumentNull(nameof(source));

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Zip.cs

@@ -41,7 +41,7 @@ namespace System.Linq
 #endif
         }
 
-        public static IAsyncEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IAsyncEnumerable<TFirst> first, IAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, ValueTask<TResult>> selector)
+        public static IAsyncEnumerable<TResult> ZipAwait<TFirst, TSecond, TResult>(this IAsyncEnumerable<TFirst> first, IAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, ValueTask<TResult>> selector)
         {
             if (first == null)
                 throw Error.ArgumentNull(nameof(first));
@@ -72,7 +72,7 @@ namespace System.Linq
         }
 
 #if !NO_DEEP_CANCELLATION
-        public static IAsyncEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IAsyncEnumerable<TFirst> first, IAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, CancellationToken, ValueTask<TResult>> selector)
+        public static IAsyncEnumerable<TResult> ZipAwaitWithCancellation<TFirst, TSecond, TResult>(this IAsyncEnumerable<TFirst> first, IAsyncEnumerable<TSecond> second, Func<TFirst, TSecond, CancellationToken, ValueTask<TResult>> selector)
         {
             if (first == null)
                 throw Error.ArgumentNull(nameof(first));