Enabling optimizations for combining N selectors

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

@@ -0,0 +1,213 @@
+// 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.Threading;
+using System.Threading.Tasks;
+
+namespace System.Linq
+{
+    public static partial class AsyncEnumerable
+    {
+        private sealed class CombinedSelectors2<TSource, TMiddle1, TResult> : ICombinedSelectors<TSource, TResult>
+        {
+            private readonly Func<TSource, TMiddle1> _selector1;
+            private readonly Func<TMiddle1, TResult> _selector2;
+
+            public CombinedSelectors2(Func<TSource, TMiddle1> selector1, Func<TMiddle1, TResult> selector2)
+            {
+                _selector1 = selector1;
+                _selector2 = selector2;
+            }
+
+            public ICombinedSelectors<TSource, TNewResult> Combine<TNewResult>(Func<TResult, TNewResult> selector) =>
+                new CombinedSelectors3<TSource, TMiddle1, TResult, TNewResult>(
+                    _selector1,
+                    _selector2,
+                    selector
+                );
+
+            public TResult Invoke(TSource x) => _selector2(_selector1(x));
+        }
+
+        private sealed class CombinedSelectors3<TSource, TMiddle1, TMiddle2, TResult> : ICombinedSelectors<TSource, TResult>
+        {
+            private readonly Func<TSource, TMiddle1> _selector1;
+            private readonly Func<TMiddle1, TMiddle2> _selector2;
+            private readonly Func<TMiddle2, TResult> _selector3;
+
+            public CombinedSelectors3(Func<TSource, TMiddle1> selector1, Func<TMiddle1, TMiddle2> selector2, Func<TMiddle2, TResult> selector3)
+            {
+                _selector1 = selector1;
+                _selector2 = selector2;
+                _selector3 = selector3;
+            }
+
+            public ICombinedSelectors<TSource, TNewResult> Combine<TNewResult>(Func<TResult, TNewResult> selector) =>
+                new CombinedSelectors4<TSource, TMiddle1, TMiddle2, TResult, TNewResult>(
+                    _selector1,
+                    _selector2,
+                    _selector3,
+                    selector
+                );
+
+            public TResult Invoke(TSource x) => _selector3(_selector2(_selector1(x)));
+        }
+
+        private sealed class CombinedSelectors4<TSource, TMiddle1, TMiddle2, TMiddle3, TResult> : ICombinedSelectors<TSource, TResult>
+        {
+            private readonly Func<TSource, TMiddle1> _selector1;
+            private readonly Func<TMiddle1, TMiddle2> _selector2;
+            private readonly Func<TMiddle2, TMiddle3> _selector3;
+            private readonly Func<TMiddle3, TResult> _selector4;
+
+            public CombinedSelectors4(Func<TSource, TMiddle1> selector1, Func<TMiddle1, TMiddle2> selector2, Func<TMiddle2, TMiddle3> selector3, Func<TMiddle3, TResult> selector4)
+            {
+                _selector1 = selector1;
+                _selector2 = selector2;
+                _selector3 = selector3;
+                _selector4 = selector4;
+            }
+
+            public ICombinedSelectors<TSource, TNewResult> Combine<TNewResult>(Func<TResult, TNewResult> selector) =>
+                new CombinedSelectors2<TSource, TResult, TNewResult>(this.Invoke, selector);
+
+            public TResult Invoke(TSource x) => _selector4(_selector3(_selector2(_selector1(x))));
+        }
+
+        private sealed class CombinedAsyncSelectors2<TSource, TMiddle1, TResult> : ICombinedAsyncSelectors<TSource, TResult>
+        {
+            private readonly Func<TSource, ValueTask<TMiddle1>> _selector1;
+            private readonly Func<TMiddle1, ValueTask<TResult>> _selector2;
+
+            public CombinedAsyncSelectors2(Func<TSource, ValueTask<TMiddle1>> selector1, Func<TMiddle1, ValueTask<TResult>> selector2)
+            {
+                _selector1 = selector1;
+                _selector2 = selector2;
+            }
+
+            public ICombinedAsyncSelectors<TSource, TNewResult> Combine<TNewResult>(Func<TResult, ValueTask<TNewResult>> selector) =>
+                new CombinedAsyncSelectors3<TSource, TMiddle1, TResult, TNewResult>(
+                    _selector1,
+                    _selector2,
+                    selector
+                );
+
+            public async ValueTask<TResult> Invoke(TSource x) => await _selector2(await _selector1(x).ConfigureAwait(false)).ConfigureAwait(false);
+        }
+
+        private sealed class CombinedAsyncSelectors3<TSource, TMiddle1, TMiddle2, TResult> : ICombinedAsyncSelectors<TSource, TResult>
+        {
+            private readonly Func<TSource, ValueTask<TMiddle1>> _selector1;
+            private readonly Func<TMiddle1, ValueTask<TMiddle2>> _selector2;
+            private readonly Func<TMiddle2, ValueTask<TResult>> _selector3;
+
+            public CombinedAsyncSelectors3(Func<TSource, ValueTask<TMiddle1>> selector1, Func<TMiddle1, ValueTask<TMiddle2>> selector2, Func<TMiddle2, ValueTask<TResult>> selector3)
+            {
+                _selector1 = selector1;
+                _selector2 = selector2;
+                _selector3 = selector3;
+            }
+
+            public ICombinedAsyncSelectors<TSource, TNewResult> Combine<TNewResult>(Func<TResult, ValueTask<TNewResult>> selector) =>
+                new CombinedAsyncSelectors4<TSource, TMiddle1, TMiddle2, TResult, TNewResult>(
+                    _selector1,
+                    _selector2,
+                    _selector3,
+                    selector
+                );
+
+            public async ValueTask<TResult> Invoke(TSource x) => await _selector3(await _selector2(await _selector1(x).ConfigureAwait(false)).ConfigureAwait(false)).ConfigureAwait(false);
+        }
+
+        private sealed class CombinedAsyncSelectors4<TSource, TMiddle1, TMiddle2, TMiddle3, TResult> : ICombinedAsyncSelectors<TSource, TResult>
+        {
+            private readonly Func<TSource, ValueTask<TMiddle1>> _selector1;
+            private readonly Func<TMiddle1, ValueTask<TMiddle2>> _selector2;
+            private readonly Func<TMiddle2, ValueTask<TMiddle3>> _selector3;
+            private readonly Func<TMiddle3, ValueTask<TResult>> _selector4;
+
+            public CombinedAsyncSelectors4(Func<TSource, ValueTask<TMiddle1>> selector1, Func<TMiddle1, ValueTask<TMiddle2>> selector2, Func<TMiddle2, ValueTask<TMiddle3>> selector3, Func<TMiddle3, ValueTask<TResult>> selector4)
+            {
+                _selector1 = selector1;
+                _selector2 = selector2;
+                _selector3 = selector3;
+                _selector4 = selector4;
+            }
+
+            public ICombinedAsyncSelectors<TSource, TNewResult> Combine<TNewResult>(Func<TResult, ValueTask<TNewResult>> selector) =>
+                new CombinedAsyncSelectors2<TSource, TResult, TNewResult>(this.Invoke, selector);
+
+            public async ValueTask<TResult> Invoke(TSource x) => await _selector4(await _selector3(await _selector2(await _selector1(x).ConfigureAwait(false)).ConfigureAwait(false)).ConfigureAwait(false)).ConfigureAwait(false);
+        }
+
+#if !NO_DEEP_CANCELLATION
+        private sealed class CombinedAsyncSelectorsWithCancellation2<TSource, TMiddle1, TResult> : ICombinedAsyncSelectorsWithCancellation<TSource, TResult>
+        {
+            private readonly Func<TSource, CancellationToken, ValueTask<TMiddle1>> _selector1;
+            private readonly Func<TMiddle1, CancellationToken, ValueTask<TResult>> _selector2;
+
+            public CombinedAsyncSelectorsWithCancellation2(Func<TSource, CancellationToken, ValueTask<TMiddle1>> selector1, Func<TMiddle1, CancellationToken, ValueTask<TResult>> selector2)
+            {
+                _selector1 = selector1;
+                _selector2 = selector2;
+            }
+
+            public ICombinedAsyncSelectorsWithCancellation<TSource, TNewResult> Combine<TNewResult>(Func<TResult, CancellationToken, ValueTask<TNewResult>> selector) =>
+                new CombinedAsyncSelectorsWithCancellation3<TSource, TMiddle1, TResult, TNewResult>(
+                    _selector1,
+                    _selector2,
+                    selector
+                );
+
+            public async ValueTask<TResult> Invoke(TSource x, CancellationToken ct) => await _selector2(await _selector1(x, ct).ConfigureAwait(false), ct).ConfigureAwait(false);
+        }
+
+        private sealed class CombinedAsyncSelectorsWithCancellation3<TSource, TMiddle1, TMiddle2, TResult> : ICombinedAsyncSelectorsWithCancellation<TSource, TResult>
+        {
+            private readonly Func<TSource, CancellationToken, ValueTask<TMiddle1>> _selector1;
+            private readonly Func<TMiddle1, CancellationToken, ValueTask<TMiddle2>> _selector2;
+            private readonly Func<TMiddle2, CancellationToken, ValueTask<TResult>> _selector3;
+
+            public CombinedAsyncSelectorsWithCancellation3(Func<TSource, CancellationToken, ValueTask<TMiddle1>> selector1, Func<TMiddle1, CancellationToken, ValueTask<TMiddle2>> selector2, Func<TMiddle2, CancellationToken, ValueTask<TResult>> selector3)
+            {
+                _selector1 = selector1;
+                _selector2 = selector2;
+                _selector3 = selector3;
+            }
+
+            public ICombinedAsyncSelectorsWithCancellation<TSource, TNewResult> Combine<TNewResult>(Func<TResult, CancellationToken, ValueTask<TNewResult>> selector) =>
+                new CombinedAsyncSelectorsWithCancellation4<TSource, TMiddle1, TMiddle2, TResult, TNewResult>(
+                    _selector1,
+                    _selector2,
+                    _selector3,
+                    selector
+                );
+
+            public async ValueTask<TResult> Invoke(TSource x, CancellationToken ct) => await _selector3(await _selector2(await _selector1(x, ct).ConfigureAwait(false), ct).ConfigureAwait(false), ct).ConfigureAwait(false);
+        }
+
+        private sealed class CombinedAsyncSelectorsWithCancellation4<TSource, TMiddle1, TMiddle2, TMiddle3, TResult> : ICombinedAsyncSelectorsWithCancellation<TSource, TResult>
+        {
+            private readonly Func<TSource, CancellationToken, ValueTask<TMiddle1>> _selector1;
+            private readonly Func<TMiddle1, CancellationToken, ValueTask<TMiddle2>> _selector2;
+            private readonly Func<TMiddle2, CancellationToken, ValueTask<TMiddle3>> _selector3;
+            private readonly Func<TMiddle3, CancellationToken, ValueTask<TResult>> _selector4;
+
+            public CombinedAsyncSelectorsWithCancellation4(Func<TSource, CancellationToken, ValueTask<TMiddle1>> selector1, Func<TMiddle1, CancellationToken, ValueTask<TMiddle2>> selector2, Func<TMiddle2, CancellationToken, ValueTask<TMiddle3>> selector3, Func<TMiddle3, CancellationToken, ValueTask<TResult>> selector4)
+            {
+                _selector1 = selector1;
+                _selector2 = selector2;
+                _selector3 = selector3;
+                _selector4 = selector4;
+            }
+
+            public ICombinedAsyncSelectorsWithCancellation<TSource, TNewResult> Combine<TNewResult>(Func<TResult, CancellationToken, ValueTask<TNewResult>> selector) =>
+                new CombinedAsyncSelectorsWithCancellation2<TSource, TResult, TNewResult>(this.Invoke, selector);
+
+            public async ValueTask<TResult> Invoke(TSource x, CancellationToken ct) => await _selector4(await _selector3(await _selector2(await _selector1(x, ct).ConfigureAwait(false), ct).ConfigureAwait(false), ct).ConfigureAwait(false), ct).ConfigureAwait(false);
+        }
+
+#endif
+    }
+}

Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Select.Opt.Generated.tt

@@ -0,0 +1,228 @@
+// 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. 
+
+<#@ template debug="false" hostspecific="false" language="C#" #>
+<#@ assembly name="System.Core" #>
+<#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Text" #>
+<#@ import namespace="System.Collections.Generic" #>
+<#@ output extension=".cs" #>
+<#
+int maxCombine = 4;
+#>
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace System.Linq
+{
+    public static partial class AsyncEnumerable
+    {
+<#
+for (var i = 2; i <= maxCombine; i++)
+{
+    Func<int, string> getInputType = j => j == 1 ? "TSource" : "TMiddle" + (j - 1);
+    Func<int, string> getOutputType = j => j == i ? "TResult" : "TMiddle" + j;
+    Func<int, string> getSelectorType = j => "Func<" + getInputType(j) + ", " + getOutputType(j) + ">";
+
+    var types = string.Join(", ", Enumerable.Range(1, i - 1).Select(j => "TMiddle" + j));
+    var allSelectors = string.Join(", ", Enumerable.Range(1, i).Select(j => getSelectorType(j) + " selector" + j));
+
+    var applyAll = Enumerable.Range(1, i).Reverse().Aggregate("", (s, j) => s + "_selector" + j + "(") + "x" + new string(')', i);
+#>
+        private sealed class CombinedSelectors<#=i#><TSource, <#=types#>, TResult> : ICombinedSelectors<TSource, TResult>
+        {
+<#
+for (var j = 1; j <= i; j++)
+{
+    var type = getSelectorType(j);
+#>
+            private readonly <#=type#> _selector<#=j#>;
+<#
+}
+#>
+
+            public CombinedSelectors<#=i#>(<#=allSelectors#>)
+            {
+<#
+for (var j = 1; j <= i; j++)
+{
+#>
+                _selector<#=j#> = selector<#=j#>;
+<#
+}
+#>
+            }
+
+            public ICombinedSelectors<TSource, TNewResult> Combine<TNewResult>(Func<TResult, TNewResult> selector) =>
+<#
+if (i == maxCombine)
+{
+#>
+                new CombinedSelectors2<TSource, TResult, TNewResult>(this.Invoke, selector);
+<#
+}
+else
+{
+#>
+                new CombinedSelectors<#=i + 1#><TSource, <#=types#>, TResult, TNewResult>(
+<#
+for (var j = 1; j <= i; j++)
+{
+#>
+                    _selector<#=j#>,
+<#
+}
+#>
+                    selector
+                );
+<#
+}
+#>
+
+            public TResult Invoke(TSource x) => <#=applyAll#>;
+        }
+
+<#
+}
+#>
+<#
+for (var i = 2; i <= maxCombine; i++)
+{
+    Func<int, string> getInputType = j => j == 1 ? "TSource" : "TMiddle" + (j - 1);
+    Func<int, string> getOutputType = j => "ValueTask<" + (j == i ? "TResult" : "TMiddle" + j) + ">";
+    Func<int, string> getSelectorType = j => "Func<" + getInputType(j) + ", " + getOutputType(j) + ">";
+
+    var types = string.Join(", ", Enumerable.Range(1, i - 1).Select(j => "TMiddle" + j));
+    var allSelectors = string.Join(", ", Enumerable.Range(1, i).Select(j => getSelectorType(j) + " selector" + j));
+
+    var applyAll = Enumerable.Range(1, i).Reverse().Aggregate("", (s, j) => s + "await _selector" + j + "(") + "x" + string.Join("", Enumerable.Repeat(").ConfigureAwait(false)", i));
+#>
+        private sealed class CombinedAsyncSelectors<#=i#><TSource, <#=types#>, TResult> : ICombinedAsyncSelectors<TSource, TResult>
+        {
+<#
+for (var j = 1; j <= i; j++)
+{
+    var type = getSelectorType(j);
+#>
+            private readonly <#=type#> _selector<#=j#>;
+<#
+}
+#>
+
+            public CombinedAsyncSelectors<#=i#>(<#=allSelectors#>)
+            {
+<#
+for (var j = 1; j <= i; j++)
+{
+#>
+                _selector<#=j#> = selector<#=j#>;
+<#
+}
+#>
+            }
+
+            public ICombinedAsyncSelectors<TSource, TNewResult> Combine<TNewResult>(Func<TResult, ValueTask<TNewResult>> selector) =>
+<#
+if (i == maxCombine)
+{
+#>
+                new CombinedAsyncSelectors2<TSource, TResult, TNewResult>(this.Invoke, selector);
+<#
+}
+else
+{
+#>
+                new CombinedAsyncSelectors<#=i + 1#><TSource, <#=types#>, TResult, TNewResult>(
+<#
+for (var j = 1; j <= i; j++)
+{
+#>
+                    _selector<#=j#>,
+<#
+}
+#>
+                    selector
+                );
+<#
+}
+#>
+
+            public async ValueTask<TResult> Invoke(TSource x) => <#=applyAll#>;
+        }
+
+<#
+}
+#>
+#if !NO_DEEP_CANCELLATION
+<#
+for (var i = 2; i <= maxCombine; i++)
+{
+    Func<int, string> getInputType = j => j == 1 ? "TSource" : "TMiddle" + (j - 1);
+    Func<int, string> getOutputType = j => "ValueTask<" + (j == i ? "TResult" : "TMiddle" + j) + ">";
+    Func<int, string> getSelectorType = j => "Func<" + getInputType(j) + ", CancellationToken, " + getOutputType(j) + ">";
+
+    var types = string.Join(", ", Enumerable.Range(1, i - 1).Select(j => "TMiddle" + j));
+    var allSelectors = string.Join(", ", Enumerable.Range(1, i).Select(j => getSelectorType(j) + " selector" + j));
+
+    var applyAll = Enumerable.Range(1, i).Reverse().Aggregate("", (s, j) => s + "await _selector" + j + "(") + "x" + string.Join("", Enumerable.Repeat(", ct).ConfigureAwait(false)", i));
+#>
+        private sealed class CombinedAsyncSelectorsWithCancellation<#=i#><TSource, <#=types#>, TResult> : ICombinedAsyncSelectorsWithCancellation<TSource, TResult>
+        {
+<#
+for (var j = 1; j <= i; j++)
+{
+    var type = getSelectorType(j);
+#>
+            private readonly <#=type#> _selector<#=j#>;
+<#
+}
+#>
+
+            public CombinedAsyncSelectorsWithCancellation<#=i#>(<#=allSelectors#>)
+            {
+<#
+for (var j = 1; j <= i; j++)
+{
+#>
+                _selector<#=j#> = selector<#=j#>;
+<#
+}
+#>
+            }
+
+            public ICombinedAsyncSelectorsWithCancellation<TSource, TNewResult> Combine<TNewResult>(Func<TResult, CancellationToken, ValueTask<TNewResult>> selector) =>
+<#
+if (i == maxCombine)
+{
+#>
+                new CombinedAsyncSelectorsWithCancellation2<TSource, TResult, TNewResult>(this.Invoke, selector);
+<#
+}
+else
+{
+#>
+                new CombinedAsyncSelectorsWithCancellation<#=i + 1#><TSource, <#=types#>, TResult, TNewResult>(
+<#
+for (var j = 1; j <= i; j++)
+{
+#>
+                    _selector<#=j#>,
+<#
+}
+#>
+                    selector
+                );
+<#
+}
+#>
+
+            public async ValueTask<TResult> Invoke(TSource x, CancellationToken ct) => <#=applyAll#>;
+        }
+
+<#
+}
+#>
+#endif
+    }
+}

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

@@ -11,18 +11,57 @@ namespace System.Linq
     {
         private static Func<TSource, TResult> CombineSelectors<TSource, TMiddle, TResult>(Func<TSource, TMiddle> selector1, Func<TMiddle, TResult> selector2)
         {
-            return x => selector2(selector1(x));
+            if (selector1.Target is ICombinedSelectors<TSource, TMiddle> c)
+            {
+                return c.Combine(selector2).Invoke;
+            }
+            else
+            {
+                return new CombinedSelectors2<TSource, TMiddle, TResult>(selector1, selector2).Invoke;
+            }
+        }
+
+        private interface ICombinedSelectors<TSource, TResult>
+        {
+            ICombinedSelectors<TSource, TNewResult> Combine<TNewResult>(Func<TResult, TNewResult> selector);
+            TResult Invoke(TSource x);
         }
 
         private static Func<TSource, ValueTask<TResult>> CombineSelectors<TSource, TMiddle, TResult>(Func<TSource, ValueTask<TMiddle>> selector1, Func<TMiddle, ValueTask<TResult>> selector2)
         {
-            return async x => await selector2(await selector1(x).ConfigureAwait(false)).ConfigureAwait(false);
+            if (selector1.Target is ICombinedAsyncSelectors<TSource, TMiddle> c)
+            {
+                return c.Combine(selector2).Invoke;
+            }
+            else
+            {
+                return new CombinedAsyncSelectors2<TSource, TMiddle, TResult>(selector1, selector2).Invoke;
+            }
+        }
+
+        private interface ICombinedAsyncSelectors<TSource, TResult>
+        {
+            ICombinedAsyncSelectors<TSource, TNewResult> Combine<TNewResult>(Func<TResult, ValueTask<TNewResult>> selector);
+            ValueTask<TResult> Invoke(TSource x);
         }
 
 #if !NO_DEEP_CANCELLATION
         private static Func<TSource, CancellationToken, ValueTask<TResult>> CombineSelectors<TSource, TMiddle, TResult>(Func<TSource, CancellationToken, ValueTask<TMiddle>> selector1, Func<TMiddle, CancellationToken, ValueTask<TResult>> selector2)
         {
-            return async (x, ct) => await selector2(await selector1(x, ct).ConfigureAwait(false), ct).ConfigureAwait(false);
+            if (selector1.Target is ICombinedAsyncSelectorsWithCancellation<TSource, TMiddle> c)
+            {
+                return c.Combine(selector2).Invoke;
+            }
+            else
+            {
+                return new CombinedAsyncSelectorsWithCancellation2<TSource, TMiddle, TResult>(selector1, selector2).Invoke;
+            }
+        }
+
+        private interface ICombinedAsyncSelectorsWithCancellation<TSource, TResult>
+        {
+            ICombinedAsyncSelectorsWithCancellation<TSource, TNewResult> Combine<TNewResult>(Func<TResult, CancellationToken, ValueTask<TNewResult>> selector);
+            ValueTask<TResult> Invoke(TSource x, CancellationToken ct);
         }
 #endif
     }