made all extensions source generated

Railway.SourceGenerator/Constants.cs

@@ -2,6 +2,5 @@ namespace Just.Railway.SourceGen;
 
 internal static class Constants
 {
-    public const int MaxResultTupleSize = 4;
-    
+    public const int MaxResultTupleSize = 5;
 }

Railway.SourceGenerator/ResultAppendExecutor.cs

@@ -0,0 +1,431 @@
+using System;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Just.Railway.SourceGen;
+
+internal sealed class ResultAppendExecutor : ResultExtensionsExecutor
+{
+    protected override string ExtensionType => "Append";
+
+    protected override void GenerateHelperMethods(StringBuilder sb)
+    {
+        sb.AppendLine("""
+        private static IEnumerable<string> GetBottom(ResultState r1, ResultState r2, string firstArg = "result", string secondArg = "next")
+        {
+            if (r1 == ResultState.Bottom)
+                yield return firstArg;
+            if (r2 == ResultState.Bottom)
+                yield return secondArg;
+        }
+        """);
+    }
+
+    protected override void GenerateMethodsForArgCount(StringBuilder sb, int argCount)
+    {
+        var templateArgNames = Enumerable.Range(1, argCount)
+            .Select(i => $"T{i}")
+            .ToImmutableArray();
+
+        string resultTypeDef = GenerateResultTypeDef(templateArgNames);
+        string resultValueExpansion = GenerateResultValueExpansion(templateArgNames);
+        string methodTemplateDecl = GenerateTemplateDecl(templateArgNames);
+
+        sb.AppendLine($"#region {resultTypeDef}");
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static {{resultTypeDef}} Append{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Result next)
+        {
+            Error? error = null;
+            if ((result.State & next.State) == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
+            }
+
+            if (result.IsFailure)
+            {
+                error += result.Error;
+            }
+            if (next.IsFailure)
+            {
+                error += next.Error;
+            }
+
+            return error is null
+                ? Result.Success({{resultValueExpansion}})
+                : error;
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static {{resultTypeDef}} Append{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Func<Result> nextFunc)
+        {
+            if (result.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(result));
+            }
+            else if (result.IsFailure)
+            {
+                return result.Error!;
+            }
+
+            var next = nextFunc();
+            if (next.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(nextFunc));
+            }
+            else if (next.IsFailure)
+            {
+                return next.Error!;
+            }
+
+            return Result.Success({{resultValueExpansion}});
+        }
+        """);
+
+        GenerateAsyncMethods("Task", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+        GenerateAsyncMethods("ValueTask", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        if (argCount < Constants.MaxResultTupleSize)
+        {
+            GenerateExpandedMethods(sb, templateArgNames, resultTypeDef, resultValueExpansion);
+            GenerateExpandedAsyncMethods("Task", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+            GenerateExpandedAsyncMethods("ValueTask", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+        }
+
+        sb.AppendLine("#endregion");
+    }
+
+    private void GenerateAsyncMethods(string taskType, StringBuilder sb, ImmutableArray<string> templateArgNames, string resultTypeDef, string resultValueExpansion)
+    {
+        string methodTemplateDecl = GenerateTemplateDecl(templateArgNames);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultTypeDef}}> Append{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func<Result> nextFunc)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            if (result.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(result));
+            }
+            else if (result.IsFailure)
+            {
+                return result.Error!;
+            }
+
+            var next = nextFunc();
+            if (next.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(nextFunc));
+            }
+            else if (next.IsFailure)
+            {
+                return next.Error!;
+            }
+
+            return Result.Success({{resultValueExpansion}});
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultTypeDef}}> Append{{methodTemplateDecl}}(this {{resultTypeDef}} result, Func<{{taskType}}<Result>> nextFunc)
+        {
+            if (result.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(result));
+            }
+            else if (result.IsFailure)
+            {
+                return result.Error!;
+            }
+
+            var next = await nextFunc().ConfigureAwait(false);
+            if (next.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(nextFunc));
+            }
+            else if (next.IsFailure)
+            {
+                return next.Error!;
+            }
+
+            return Result.Success({{resultValueExpansion}});
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultTypeDef}}> Append{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func<{{taskType}}<Result>> nextFunc)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            if (result.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(resultTask));
+            }
+            else if (result.IsFailure)
+            {
+                return result.Error!;
+            }
+
+            var next = await nextFunc().ConfigureAwait(false);
+            if (next.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(nextFunc));
+            }
+            else if (next.IsFailure)
+            {
+                return next.Error!;
+            }
+
+            return Result.Success({{resultValueExpansion}});
+        }
+        """);
+    }
+
+    private void GenerateExpandedAsyncMethods(string taskType, StringBuilder sb, ImmutableArray<string> templateArgNames, string resultTypeDef, string resultValueExpansion)
+    {
+        var expandedTemplateArgNames = templateArgNames.Add("TNext");
+        string resultExpandedTypeDef = GenerateResultTypeDef(expandedTemplateArgNames);
+        string methodExpandedTemplateDecl = GenerateTemplateDecl(expandedTemplateArgNames);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultExpandedTypeDef}}> Append{{methodExpandedTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func<TNext> nextFunc)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            return result.State switch
+            {
+                ResultState.Success => Result.Success({{JoinArguments(resultValueExpansion, "nextFunc()")}}),
+                ResultState.Error => result.Error!,
+                _ => throw new ResultNotInitializedException(nameof(result))
+            };
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultExpandedTypeDef}}> Append{{methodExpandedTemplateDecl}}(this {{resultTypeDef}} result, Func<{{taskType}}<TNext>> nextFunc)
+        {
+            return result.State switch
+            {
+                ResultState.Success => Result.Success({{JoinArguments(resultValueExpansion, "await nextFunc().ConfigureAwait(false)")}}),
+                ResultState.Error => result.Error!,
+                _ => throw new ResultNotInitializedException(nameof(result))
+            };
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultExpandedTypeDef}}> Append{{methodExpandedTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func<{{taskType}}<TNext>> nextFunc)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            return result.State switch
+            {
+                ResultState.Success => Result.Success({{JoinArguments(resultValueExpansion, "await nextFunc().ConfigureAwait(false)")}}),
+                ResultState.Error => result.Error!,
+                _ => throw new ResultNotInitializedException(nameof(result))
+            };
+        }
+        """);
+
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultExpandedTypeDef}}> Append{{methodExpandedTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func<Result<TNext>> nextFunc)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            if (result.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(resultTask));
+            }
+            else if (result.IsFailure)
+            {
+                return result.Error!;
+            }
+
+            var next = nextFunc();
+            if (next.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(nextFunc));
+            }
+            else if (next.IsFailure)
+            {
+                return next.Error!;
+            }
+
+            return Result.Success({{JoinArguments(resultValueExpansion, "next.Value")}});
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultExpandedTypeDef}}> Append{{methodExpandedTemplateDecl}}(this {{resultTypeDef}} result, Func<{{taskType}}<Result<TNext>>> nextFunc)
+        {
+            if (result.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(result));
+            }
+            else if (result.IsFailure)
+            {
+                return result.Error!;
+            }
+
+            var next = await nextFunc().ConfigureAwait(false);
+            if (next.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(nextFunc));
+            }
+            else if (next.IsFailure)
+            {
+                return next.Error!;
+            }
+
+            return Result.Success({{JoinArguments(resultValueExpansion, "next.Value")}});
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultExpandedTypeDef}}> Append{{methodExpandedTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func<{{taskType}}<Result<TNext>>> nextFunc)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            if (result.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(resultTask));
+            }
+            else if (result.IsFailure)
+            {
+                return result.Error!;
+            }
+
+            var next = await nextFunc().ConfigureAwait(false);
+            if (next.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(nextFunc));
+            }
+            else if (next.IsFailure)
+            {
+                return next.Error!;
+            }
+
+            return Result.Success({{JoinArguments(resultValueExpansion, "next.Value")}});
+        }
+        """);
+    }
+
+    private static void GenerateExpandedMethods(StringBuilder sb, ImmutableArray<string> templateArgNames, string resultTypeDef, string resultValueExpansion)
+    {
+        var expandedTemplateArgNames = templateArgNames.Add("TNext");
+        string resultExpandedTypeDef = GenerateResultTypeDef(expandedTemplateArgNames);
+        string methodExpandedTemplateDecl = GenerateTemplateDecl(expandedTemplateArgNames);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static {{resultExpandedTypeDef}} Append{{methodExpandedTemplateDecl}}(this in {{resultTypeDef}} result, TNext next)
+        {
+            return result.State switch
+            {
+                ResultState.Success => Result.Success({{JoinArguments(resultValueExpansion, "next")}}),
+                ResultState.Error => result.Error!,
+                _ => throw new ResultNotInitializedException(nameof(result))
+            };
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static {{resultExpandedTypeDef}} Append{{methodExpandedTemplateDecl}}(this in {{resultTypeDef}} result, Func<TNext> nextFunc)
+        {
+            return result.State switch
+            {
+                ResultState.Success => Result.Success({{JoinArguments(resultValueExpansion, "nextFunc()")}}),
+                ResultState.Error => result.Error!,
+                _ => throw new ResultNotInitializedException(nameof(result))
+            };
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static {{resultExpandedTypeDef}} Append{{methodExpandedTemplateDecl}}(this in {{resultTypeDef}} result, Result<TNext> next)
+        {
+            Error? error = null;
+            if ((result.State & next.State) == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
+            }
+
+            if (result.IsFailure)
+            {
+                error += result.Error;
+            }
+            if (next.IsFailure)
+            {
+                error += next.Error;
+            }
+
+            return error is null
+                ? Result.Success({{JoinArguments(resultValueExpansion, "next.Value")}})
+                : error;
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultAppendExecutor)}}", "1.0.0.0")]
+        public static {{resultExpandedTypeDef}} Append{{methodExpandedTemplateDecl}}(this in {{resultTypeDef}} result, Func<Result<TNext>> nextFunc)
+        {
+            if (result.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(result));
+            }
+            else if (result.IsFailure)
+            {
+                return result.Error!;
+            }
+
+            var next = nextFunc();
+            if (next.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(nextFunc));
+            }
+            else if (next.IsFailure)
+            {
+                return next.Error!;
+            }
+
+            return Result.Success({{JoinArguments(resultValueExpansion, "next.Value")}});
+        }
+        """);
+    }
+
+    internal static string JoinArguments(string arg1, string arg2) => (arg1, arg2) switch
+    {
+        ("", "") => "",
+        (string arg, "") => arg,
+        ("", string arg) => arg,
+        _ => $"{arg1}, {arg2}"
+    };
+}

Railway.SourceGenerator/ResultBindExecutor.cs

@@ -14,17 +14,18 @@ internal sealed class ResultBindExecutor : ResultExtensionsExecutor
         var templateArgNames = Enumerable.Range(1, argCount)
             .Select(i => $"T{i}")
             .ToImmutableArray();
-        string separatedTemplateArgs = string.Join(", ", templateArgNames);
 
-        sb.AppendLine($"#region <{separatedTemplateArgs}>");
-
-        string resultValueType = templateArgNames.Length == 1 ? separatedTemplateArgs : $"({separatedTemplateArgs})";
+        string resultTypeDef = GenerateResultTypeDef(templateArgNames);
         string resultValueExpansion = GenerateResultValueExpansion(templateArgNames);
+        string methodTemplateDecl = GenerateTemplateDecl(templateArgNames.Add("R"));
+        string bindTemplateDecl = GenerateTemplateDecl(templateArgNames.Add("Result<R>"));
+
+        sb.AppendLine($"#region {resultTypeDef}");
 
         sb.AppendLine($$"""
         [PureAttribute]
         [GeneratedCodeAttribute("{{nameof(ResultBindExecutor)}}", "1.0.0.0")]
-        public static Result<R> Bind<{{separatedTemplateArgs}}, R>(this in Result<{{resultValueType}}> result, Func<{{separatedTemplateArgs}}, Result<R>> binding)
+        public static Result<R> Bind{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Func{{bindTemplateDecl}} binding)
         {
             return result.State switch
             {
@@ -35,24 +36,22 @@ internal sealed class ResultBindExecutor : ResultExtensionsExecutor
         }
         """);
 
-        sb.AppendLine($$"""
-        [PureAttribute]
-        [GeneratedCodeAttribute("{{nameof(ResultBindExecutor)}}", "1.0.0.0")]
-        public static Task<Result<R>> Bind<{{separatedTemplateArgs}}, R>(this in Result<{{resultValueType}}> result, Func<{{separatedTemplateArgs}}, Task<Result<R>>> binding)
-        {
-            return result.State switch
-            {
-                ResultState.Success => binding({{resultValueExpansion}}),
-                ResultState.Error => Task.FromResult<Result<R>>(result.Error!),
-                _ => throw new ResultNotInitializedException(nameof(result))
-            };
-        }
-        """);
+        GenerateAsyncMethods("Task", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+        GenerateAsyncMethods("ValueTask", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        sb.AppendLine("#endregion");
+    }
+
+    private static void GenerateAsyncMethods(string taskType, StringBuilder sb, ImmutableArray<string> templateArgNames, string resultTypeDef, string resultValueExpansion)
+    {
+        string methodTemplateDecl = GenerateTemplateDecl(templateArgNames.Add("R"));
+        string bindTemplateDecl = GenerateTemplateDecl(templateArgNames.Add("Result<R>"));
+        string asyncActionTemplateDecl = GenerateTemplateDecl(templateArgNames.Add($"{taskType}<Result<R>>"));
 
         sb.AppendLine($$"""
         [PureAttribute]
         [GeneratedCodeAttribute("{{nameof(ResultBindExecutor)}}", "1.0.0.0")]
-        public static async Task<Result<R>> Bind<{{separatedTemplateArgs}}, R>(this Task<Result<{{resultValueType}}>> resultTask, Func<{{separatedTemplateArgs}}, Result<R>> binding)
+        public static async {{taskType}}<Result<R>> Bind{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{bindTemplateDecl}} binding)
         {
             var result = await resultTask.ConfigureAwait(false);
             return result.State switch
@@ -67,7 +66,21 @@ internal sealed class ResultBindExecutor : ResultExtensionsExecutor
         sb.AppendLine($$"""
         [PureAttribute]
         [GeneratedCodeAttribute("{{nameof(ResultBindExecutor)}}", "1.0.0.0")]
-        public static async Task<Result<R>> Bind<{{separatedTemplateArgs}}, R>(this Task<Result<{{resultValueType}}>> resultTask, Func<{{separatedTemplateArgs}}, Task<Result<R>>> binding)
+        public static {{taskType}}<Result<R>> Bind{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Func{{asyncActionTemplateDecl}} binding)
+        {
+            return result.State switch
+            {
+                ResultState.Success => binding({{resultValueExpansion}}),
+                ResultState.Error => {{taskType}}.FromResult<Result<R>>(result.Error!),
+                _ => throw new ResultNotInitializedException(nameof(result))
+            };
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultBindExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<Result<R>> Bind{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{asyncActionTemplateDecl}} binding)
         {
             var result = await resultTask.ConfigureAwait(false);
             return result.State switch
@@ -78,7 +91,5 @@ internal sealed class ResultBindExecutor : ResultExtensionsExecutor
             };
         }
         """);
-
-        sb.AppendLine("#endregion");
     }
 }

Railway.SourceGenerator/ResultCombineExecutor.cs

@@ -49,10 +49,19 @@ internal sealed class ResultCombineExecutor : IGeneratorExecutor
 
         GenerateGetBottomMethod(sb, argCount);
 
-        var argsResultTupleSizes = new List<ImmutableArray<int>>();
-        Span<int> templateCounts = stackalloc int[argCount];
+        var permutations = 1 << argCount;
+        var argsResultTupleSizes = new ImmutableArray<int>[permutations];
 
-        Permute(templateCounts, argsResultTupleSizes);
+        Span<int> templateCounts = stackalloc int[argCount];
+        for (int i = 0; i < permutations; i++)
+        {
+            templateCounts.Fill(0);
+            for (int j = 0; j < argCount; j++)
+            {
+                templateCounts[j] = (i & (1 << j)) > 0 ? 1 : 0;
+            }
+            argsResultTupleSizes[i] = templateCounts.ToImmutableArray();
+        }
 
         foreach (var argResultTupleSizes in argsResultTupleSizes)
         {
@@ -61,23 +70,6 @@ internal sealed class ResultCombineExecutor : IGeneratorExecutor
 
         sb.AppendLine("#endregion");
 
-        static void Permute(Span<int> templateCounts, ICollection<ImmutableArray<int>> argsResultTupleSizes, int lvl = 0)
-        {
-            int sum = 0;
-            for (int i = 0; i < lvl; i++)
-            {
-                sum += templateCounts[i];
-            }
-            for (templateCounts[lvl] = 0; templateCounts[lvl] <= Constants.MaxResultTupleSize - sum; templateCounts[lvl]++)
-            {
-                if (lvl == templateCounts.Length - 1)
-                {
-                    argsResultTupleSizes.Add(templateCounts.ToImmutableArray());
-                    continue;
-                }
-                Permute(templateCounts, argsResultTupleSizes, lvl + 1);
-            }
-        }
     }
 
     private static void GenerateGetBottomMethod(StringBuilder sb, int argCount)

Railway.SourceGenerator/ResultExtensionsExecutor.cs

@@ -31,7 +31,8 @@ internal abstract class ResultExtensionsExecutor : IGeneratorExecutor
     {
         var sb = new StringBuilder();
 
-        for (int i = 1; i <= Constants.MaxResultTupleSize; i++)
+        GenerateHelperMethods(sb);
+        for (int i = 0; i <= Constants.MaxResultTupleSize; i++)
         {
             GenerateMethodsForArgCount(sb, argCount: i);
         }
@@ -39,11 +40,32 @@ internal abstract class ResultExtensionsExecutor : IGeneratorExecutor
         return sb.ToString();
     }
 
-    protected string GenerateResultValueExpansion(ImmutableArray<string> templateArgNames)
+    protected static string GenerateTemplateDecl(ImmutableArray<string> templateArgNames) => templateArgNames.Length > 0
+        ? $"<{string.Join(", ", templateArgNames)}>"
+        : string.Empty;
+
+    protected static string GenerateResultTypeDef(ImmutableArray<string> templateArgNames) => templateArgNames.Length switch
+        {
+            0 => "Result",
+            1 => $"Result<{string.Join(", ", templateArgNames)}>",
+            _ => $"Result<({string.Join(", ", templateArgNames)})>",
+        };
+
+    protected static string GenerateResultValueExpansion(ImmutableArray<string> templateArgNames)
     {
         string resultExpansion;
-        if (templateArgNames.Length > 1)
+
+        switch (templateArgNames.Length)
         {
+            case 0:
+            resultExpansion = string.Empty;
+            break;
+
+            case 1:
+            resultExpansion = "result.Value";
+            break;
+
+            default:
             var resultExpansionBuilder = new StringBuilder();
             for (int i = 1; i <= templateArgNames.Length; i++)
             {
@@ -51,10 +73,7 @@ internal abstract class ResultExtensionsExecutor : IGeneratorExecutor
             }
             resultExpansionBuilder.Remove(resultExpansionBuilder.Length - 2, 2);
             resultExpansion = resultExpansionBuilder.ToString();
-        }
-        else
-        {
-            resultExpansion = "result.Value";
+            break;
         }
 
         return resultExpansion;
@@ -62,4 +81,5 @@ internal abstract class ResultExtensionsExecutor : IGeneratorExecutor
 
     protected abstract string ExtensionType { get; }
     protected abstract void GenerateMethodsForArgCount(StringBuilder sb, int argCount);
+    protected virtual void GenerateHelperMethods(StringBuilder sb) {}
 }

Railway.SourceGenerator/ResultMapExecutor.cs

@@ -13,17 +13,17 @@ internal sealed class ResultMapExecutor : ResultExtensionsExecutor
         var templateArgNames = Enumerable.Range(1, argCount)
             .Select(i => $"T{i}")
             .ToImmutableArray();
-        string separatedTemplateArgs = string.Join(", ", templateArgNames);
 
-        sb.AppendLine($"#region <{separatedTemplateArgs}>");
-
-        string resultValueType = templateArgNames.Length == 1 ? separatedTemplateArgs : $"({separatedTemplateArgs})";
+        string resultTypeDef = GenerateResultTypeDef(templateArgNames);
         string resultValueExpansion = GenerateResultValueExpansion(templateArgNames);
+        string methodTemplateDecl = GenerateTemplateDecl(templateArgNames.Add("R"));
+
+        sb.AppendLine($"#region {resultTypeDef}");
 
         sb.AppendLine($$"""
         [PureAttribute]
         [GeneratedCodeAttribute("{{nameof(ResultMapExecutor)}}", "1.0.0.0")]
-        public static Result<R> Map<{{separatedTemplateArgs}}, R>(this in Result<{{resultValueType}}> result, Func<{{separatedTemplateArgs}}, R> mapping)
+        public static Result<R> Map{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Func{{methodTemplateDecl}} mapping)
         {
             return result.State switch
             {
@@ -34,50 +34,60 @@ internal sealed class ResultMapExecutor : ResultExtensionsExecutor
         }
         """);
 
-        sb.AppendLine($$"""
-        [PureAttribute]
-        [GeneratedCodeAttribute("{{nameof(ResultMapExecutor)}}", "1.0.0.0")]
-        public static async Task<Result<R>> Map<{{separatedTemplateArgs}}, R>(this Result<{{resultValueType}}> result, Func<{{separatedTemplateArgs}}, Task<R>> mapping)
-        {
-            return result.State switch
-            {
-                ResultState.Success => await mapping({{resultValueExpansion}}).ConfigureAwait(false),
-                ResultState.Error => result.Error!,
-                _ => throw new ResultNotInitializedException(nameof(result))
-            };
-        }
-        """);
-
-        sb.AppendLine($$"""
-        [PureAttribute]
-        [GeneratedCodeAttribute("{{nameof(ResultMapExecutor)}}", "1.0.0.0")]
-        public static async Task<Result<R>> Map<{{separatedTemplateArgs}}, R>(this Task<Result<{{resultValueType}}>> resultTask, Func<{{separatedTemplateArgs}}, R> mapping)
-        {
-            var result = await resultTask.ConfigureAwait(false);
-            return result.State switch
-            {
-                ResultState.Success => mapping({{resultValueExpansion}}),
-                ResultState.Error => result.Error!,
-                _ => throw new ResultNotInitializedException(nameof(resultTask))
-            };
-        }
-        """);
-
-        sb.AppendLine($$"""
-        [PureAttribute]
-        [GeneratedCodeAttribute("{{nameof(ResultMapExecutor)}}", "1.0.0.0")]
-        public static async Task<Result<R>> Map<{{separatedTemplateArgs}}, R>(this Task<Result<{{resultValueType}}>> resultTask, Func<{{separatedTemplateArgs}}, Task<R>> mapping)
-        {
-            var result = await resultTask.ConfigureAwait(false);
-            return result.State switch
-            {
-                ResultState.Success => await mapping({{resultValueExpansion}}).ConfigureAwait(false),
-                ResultState.Error => result.Error!,
-                _ => throw new ResultNotInitializedException(nameof(resultTask))
-            };
-        }
-        """);
+        GenerateAsyncMethods("Task", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+        GenerateAsyncMethods("ValueTask", sb, templateArgNames, resultTypeDef, resultValueExpansion);
 
         sb.AppendLine("#endregion");
     }
+
+    private static void GenerateAsyncMethods(string taskType, StringBuilder sb, ImmutableArray<string> templateArgNames, string resultTypeDef, string resultValueExpansion)
+    {
+        var methodTemplateArgNames = templateArgNames.Add("R");
+        string methodTemplateDecl = GenerateTemplateDecl(methodTemplateArgNames);
+        string asyncActionTemplateDecl = GenerateTemplateDecl(templateArgNames.Add($"{taskType}<R>"));
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultMapExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<Result<R>> Map{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{methodTemplateDecl}} mapping)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            return result.State switch
+            {
+                ResultState.Success => mapping({{resultValueExpansion}}),
+                ResultState.Error => result.Error!,
+                _ => throw new ResultNotInitializedException(nameof(resultTask))
+            };
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultMapExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<Result<R>> Map{{methodTemplateDecl}}(this {{resultTypeDef}} result, Func{{asyncActionTemplateDecl}} mapping)
+        {
+            return result.State switch
+            {
+                ResultState.Success => await mapping({{resultValueExpansion}}).ConfigureAwait(false),
+                ResultState.Error => result.Error!,
+                _ => throw new ResultNotInitializedException(nameof(result))
+            };
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultMapExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<Result<R>> Map{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{asyncActionTemplateDecl}} mapping)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            return result.State switch
+            {
+                ResultState.Success => await mapping({{resultValueExpansion}}).ConfigureAwait(false),
+                ResultState.Error => result.Error!,
+                _ => throw new ResultNotInitializedException(nameof(resultTask))
+            };
+        }
+        """);
+    }
 }

Railway.SourceGenerator/ResultMatchExecutor.cs

@@ -16,17 +16,17 @@ internal sealed class ResultMatchExecutor : ResultExtensionsExecutor
         var templateArgNames = Enumerable.Range(1, argCount)
             .Select(i => $"T{i}")
             .ToImmutableArray();
-        string separatedTemplateArgs = string.Join(", ", templateArgNames);
 
-        sb.AppendLine($"#region <{separatedTemplateArgs}>");
-
-        string resultValueType = templateArgNames.Length == 1 ? separatedTemplateArgs : $"({separatedTemplateArgs})";
+        string resultTypeDef = GenerateResultTypeDef(templateArgNames);
         string resultValueExpansion = GenerateResultValueExpansion(templateArgNames);
+        string methodTemplateDecl = GenerateTemplateDecl(templateArgNames.Add("R"));
+
+        sb.AppendLine($"#region {resultTypeDef}");
 
         sb.AppendLine($$"""
         [PureAttribute]
         [GeneratedCodeAttribute("{{nameof(ResultMatchExecutor)}}", "1.0.0.0")]
-        public static R Match<{{separatedTemplateArgs}}, R>(this in Result<{{resultValueType}}> result, Func<{{separatedTemplateArgs}}, R> onSuccess, Func<Error, R> onFailure)
+        public static R Match{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Func{{methodTemplateDecl}} onSuccess, Func<Error, R> onFailure)
         {
             return result.State switch
             {
@@ -37,24 +37,22 @@ internal sealed class ResultMatchExecutor : ResultExtensionsExecutor
         }
         """);
 
-        sb.AppendLine($$"""
-        [PureAttribute]
-        [GeneratedCodeAttribute("{{nameof(ResultMatchExecutor)}}", "1.0.0.0")]
-        public static Task<R> Match<{{separatedTemplateArgs}}, R>(this in Result<{{resultValueType}}> result, Func<{{separatedTemplateArgs}}, Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
-        {
-            return result.State switch
-            {
-                ResultState.Success => onSuccess({{resultValueExpansion}}),
-                ResultState.Error => onFailure(result.Error!),
-                _ => throw new ResultNotInitializedException(nameof(result))
-            };
-        }
-        """);
+        GenerateAsyncMethods("Task", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+        GenerateAsyncMethods("ValueTask", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        sb.AppendLine("#endregion");
+    }
+
+    private static void GenerateAsyncMethods(string taskType, StringBuilder sb, ImmutableArray<string> templateArgNames, string resultTypeDef, string resultValueExpansion)
+    {
+        var methodTemplateArgNames = templateArgNames.Add("R");
+        string methodTemplateDecl = GenerateTemplateDecl(methodTemplateArgNames);
+        string asyncActionTemplateDecl = GenerateTemplateDecl(templateArgNames.Add($"{taskType}<R>"));
 
         sb.AppendLine($$"""
         [PureAttribute]
         [GeneratedCodeAttribute("{{nameof(ResultMatchExecutor)}}", "1.0.0.0")]
-        public static async Task<R> Match<{{separatedTemplateArgs}}, R>(this Task<Result<{{resultValueType}}>> resultTask, Func<{{separatedTemplateArgs}}, R> onSuccess, Func<Error, R> onFailure)
+        public static async {{taskType}}<R> Match{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{methodTemplateDecl}} onSuccess, Func<Error, R> onFailure)
         {
             var result = await resultTask.ConfigureAwait(false);
             return result.State switch
@@ -69,7 +67,21 @@ internal sealed class ResultMatchExecutor : ResultExtensionsExecutor
         sb.AppendLine($$"""
         [PureAttribute]
         [GeneratedCodeAttribute("{{nameof(ResultMatchExecutor)}}", "1.0.0.0")]
-        public static async Task<R> Match<{{separatedTemplateArgs}}, R>(this Task<Result<{{resultValueType}}>> resultTask, Func<{{separatedTemplateArgs}}, Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
+        public static {{taskType}}<R> Match{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Func{{asyncActionTemplateDecl}} onSuccess, Func<Error, {{taskType}}<R>> onFailure)
+        {
+            return result.State switch
+            {
+                ResultState.Success => onSuccess({{resultValueExpansion}}),
+                ResultState.Error => onFailure(result.Error!),
+                _ => throw new ResultNotInitializedException(nameof(result))
+            };
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultMatchExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<R> Match{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{asyncActionTemplateDecl}} onSuccess, Func<Error, {{taskType}}<R>> onFailure)
         {
             var result = await resultTask.ConfigureAwait(false);
             var matchTask = result.State switch
@@ -81,7 +93,5 @@ internal sealed class ResultMatchExecutor : ResultExtensionsExecutor
             return await matchTask.ConfigureAwait(false);
         }
         """);
-
-        sb.AppendLine("#endregion");
     }
 }

Railway.SourceGenerator/ResultMethodGenerator.cs

@@ -17,6 +17,7 @@ public class ResultMethodGenerator : IIncrementalGenerator
         new ResultMapExecutor(),
         new ResultBindExecutor(),
         new ResultTapExecutor(),
+        new ResultAppendExecutor(),
     };
 
     public void Initialize(IncrementalGeneratorInitializationContext context)

Railway.SourceGenerator/ResultTapExecutor.cs

@@ -14,17 +14,17 @@ internal sealed class ResultTapExecutor : ResultExtensionsExecutor
         var templateArgNames = Enumerable.Range(1, argCount)
             .Select(i => $"T{i}")
             .ToImmutableArray();
-        string separatedTemplateArgs = string.Join(", ", templateArgNames);
 
-        sb.AppendLine($"#region <{separatedTemplateArgs}>");
-
-        string resultValueType = templateArgNames.Length == 1 ? separatedTemplateArgs : $"({separatedTemplateArgs})";
+        string methodTemplateDecl = GenerateTemplateDecl(templateArgNames);
+        string resultTypeDef = GenerateResultTypeDef(templateArgNames);
         string resultValueExpansion = GenerateResultValueExpansion(templateArgNames);
 
+        sb.AppendLine($"#region {resultTypeDef}");
+
         sb.AppendLine($$"""
         [PureAttribute]
         [GeneratedCodeAttribute("{{nameof(ResultTapExecutor)}}", "1.0.0.0")]
-        public static ref readonly Result<{{resultValueType}}> Tap<{{separatedTemplateArgs}}>(this in Result<{{resultValueType}}> result, Action<{{separatedTemplateArgs}}>? onSuccess = null, Action<Error>? onFailure = null)
+        public static ref readonly {{resultTypeDef}} Tap{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Action{{methodTemplateDecl}}? onSuccess = null, Action<Error>? onFailure = null)
         {
             switch (result.State)
             {
@@ -41,10 +41,21 @@ internal sealed class ResultTapExecutor : ResultExtensionsExecutor
         }
         """);
 
+        GenerateAsyncMethods("Task", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+        GenerateAsyncMethods("ValueTask", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        sb.AppendLine("#endregion");
+    }
+
+    private static void GenerateAsyncMethods(string taskType, StringBuilder sb, ImmutableArray<string> templateArgNames, string resultTypeDef, string resultValueExpansion)
+    {
+        string methodTemplateDecl = GenerateTemplateDecl(templateArgNames);
+        string asyncActionTemplateDecl = GenerateTemplateDecl(templateArgNames.Add(taskType));
+
         sb.AppendLine($$"""
         [PureAttribute]
         [GeneratedCodeAttribute("{{nameof(ResultTapExecutor)}}", "1.0.0.0")]
-        public static async Task<Result<{{resultValueType}}>> Tap<{{separatedTemplateArgs}}>(this Task<Result<{{resultValueType}}>> resultTask, Action<{{separatedTemplateArgs}}>? onSuccess = null, Action<Error>? onFailure = null)
+        public static async {{taskType}}<{{resultTypeDef}}> Tap{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Action{{methodTemplateDecl}}? onSuccess = null, Action<Error>? onFailure = null)
         {
             var result = await resultTask.ConfigureAwait(false);
             switch (result.State)
@@ -65,7 +76,7 @@ internal sealed class ResultTapExecutor : ResultExtensionsExecutor
         sb.AppendLine($$"""
         [PureAttribute]
         [GeneratedCodeAttribute("{{nameof(ResultTapExecutor)}}", "1.0.0.0")]
-        public static async Task<Result<{{resultValueType}}>> Tap<{{separatedTemplateArgs}}>(this Result<{{resultValueType}}> result, Func<{{separatedTemplateArgs}}, Task>? onSuccess = null, Func<Error, Task>? onFailure = null)
+        public static async {{taskType}}<{{resultTypeDef}}> Tap{{methodTemplateDecl}}(this {{resultTypeDef}} result, Func{{asyncActionTemplateDecl}}? onSuccess = null, Func<Error, {{taskType}}>? onFailure = null)
         {
             switch (result.State)
             {
@@ -87,7 +98,7 @@ internal sealed class ResultTapExecutor : ResultExtensionsExecutor
         sb.AppendLine($$"""
         [PureAttribute]
         [GeneratedCodeAttribute("{{nameof(ResultTapExecutor)}}", "1.0.0.0")]
-        public static async Task<Result<{{resultValueType}}>> Tap<{{separatedTemplateArgs}}>(this Task<Result<{{resultValueType}}>> resultTask, Func<{{separatedTemplateArgs}}, Task>? onSuccess = null, Func<Error, Task>? onFailure = null)
+        public static async {{taskType}}<{{resultTypeDef}}> Tap{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{asyncActionTemplateDecl}}? onSuccess = null, Func<Error, {{taskType}}>? onFailure = null)
         {
             var result = await resultTask.ConfigureAwait(false);
             switch (result.State)
@@ -106,7 +117,5 @@ internal sealed class ResultTapExecutor : ResultExtensionsExecutor
             return result;
         }
         """);
-
-        sb.AppendLine("#endregion");
     }
 }

Railway/Railway.csproj

@@ -8,6 +8,7 @@
     <RootNamespace>Just.Railway</RootNamespace>
     
     <Authors>JustFixMe</Authors>
+    <Copyright>Copyright (c) 2023 JustFixMe</Copyright>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <RepositoryUrl>https://gitea.jstdev.ru/just/Just.Railway/</RepositoryUrl>
     

Railway/Result.cs

@@ -17,13 +17,34 @@ public readonly partial struct Result : IEquatable<Result>
         State = error is null ? ResultState.Success : ResultState.Error;
     }
 
-    [Pure] public static Result Success() => new(null);
-    [Pure] public static Result<T> Success<T>(T value) => new(value);
-    [Pure] public static Result Failure(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
-    [Pure] public static Result<T> Failure<T>(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Result Success() => new(null);
 
-    [Pure] public static implicit operator Result(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
-    [Pure] public static implicit operator Result<SuccessUnit>(Result result) => result.State switch
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Result<T> Success<T>(T value) => new(value);
+
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Result<(T1, T2)> Success<T1, T2>(T1 value1, T2 value2) => new((value1, value2));
+    
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Result<(T1, T2, T3)> Success<T1, T2, T3>(T1 value1, T2 value2, T3 value3) => new((value1, value2, value3));
+    
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Result<(T1, T2, T3, T4)> Success<T1, T2, T3, T4>(T1 value1, T2 value2, T3 value3, T4 value4) => new((value1, value2, value3, value4));
+    
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Result<(T1, T2, T3, T4, T5)> Success<T1, T2, T3, T4, T5>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5) => new((value1, value2, value3, value4, value5));
+
+
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Result Failure(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Result<T> Failure<T>(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
+
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator Result(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator Result<SuccessUnit>(Result result) => result.State switch
     {
         ResultState.Success => new(new SuccessUnit()),
         ResultState.Error => new(result.Error!),

Railway/ResultExtensions.cs

@@ -2,770 +2,41 @@ namespace Just.Railway;
 
 public static partial class ResultExtensions
 {
-    #region Match<>
-
-    [Pure]
-    public static R Match<R>(this in Result result, Func<R> onSuccess, Func<Error, R> onFailure)
-    {
-        return result.State switch
-        {
-            ResultState.Success => onSuccess(),
-            ResultState.Error => onFailure(result.Error!),
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-
-    [Pure]
-    public static Task<R> Match<R>(this in Result result, Func<Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
-    {
-        return result.State switch
-        {
-            ResultState.Success => onSuccess(),
-            ResultState.Error => onFailure(result.Error!),
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-
-    [Pure] public static async Task<R> Match<R>(this Task<Result> resultTask, Func<R> onSuccess, Func<Error, R> onFailure)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => onSuccess(),
-            ResultState.Error => onFailure(result.Error!),
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-    [Pure]
-    public static async Task<R> Match<R>(this Task<Result> resultTask, Func<Task<R>> onSuccess, Func<Error, Task<R>> onFailure)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        var matchTask = result.State switch
-        {
-            ResultState.Success => onSuccess(),
-            ResultState.Error => onFailure(result.Error!),
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-        return await matchTask.ConfigureAwait(false);
-    }
-
-    #endregion
-
-    #region Map<>
-
-    [Pure]
-    public static Result<R> Map<R>(this in Result result, Func<R> mapping)
-    {
-        return result.State switch
-        {
-            ResultState.Success => mapping(),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-
-    [Pure]
-    public static async Task<Result<R>> Map<R>(this Result result, Func<Task<R>> mapping)
-    {
-        return result.State switch
-        {
-            ResultState.Success => await mapping().ConfigureAwait(false),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-
-    [Pure]
-    public static async Task<Result<R>> Map<R>(this Task<Result> resultTask, Func<R> mapping)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => mapping(),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-
-    [Pure]
-    public static async Task<Result<R>> Map<R>(this Task<Result> resultTask, Func<Task<R>> mapping)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => await mapping().ConfigureAwait(false),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-
-    #endregion
-
-    #region Bind<>
-
-    [Pure]
-    public static Result Bind(this in Result result, Func<Result> binding)
-    {
-        return result.State switch
-        {
-            ResultState.Success => binding(),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure]
-    public static Task<Result> Bind(this in Result result, Func<Task<Result>> binding)
-    {
-        return result.State switch
-        {
-            ResultState.Success => binding(),
-            ResultState.Error => Task.FromResult<Result>(result.Error!),
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure]
-    public static async Task<Result> Bind(this Task<Result> resultTask, Func<Result> binding)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => binding(),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-    [Pure]
-    public static async Task<Result> Bind(this Task<Result> resultTask, Func<Task<Result>> binding)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => await binding().ConfigureAwait(false),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-
-    [Pure]
-    public static Result<R> Bind<R>(this in Result result, Func<Result<R>> binding)
-    {
-        return result.State switch
-        {
-            ResultState.Success => binding(),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure]
-    public static Task<Result<R>> Bind<R>(this in Result result, Func<Task<Result<R>>> binding)
-    {
-        return result.State switch
-        {
-            ResultState.Success => binding(),
-            ResultState.Error => Task.FromResult<Result<R>>(result.Error!),
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure]
-    public static async Task<Result<R>> Bind<R>(this Task<Result> resultTask, Func<Result<R>> binding)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => binding(),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-    [Pure]
-    public static async Task<Result<R>> Bind<R>(this Task<Result> resultTask, Func<Task<Result<R>>> binding)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => await binding().ConfigureAwait(false),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-
-    #endregion
-
-    #region Append
-
-    #region <>
-
-    [Pure] public static Result Append(this in Result result, Result next)
-    {
-        Error? error = null;
-
-        if ((result.State & next.State) == ResultState.Bottom)
-        {
-            throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
-
-            static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
-            {
-                if (r1 == ResultState.Bottom)
-                    yield return nameof(result);
-                if (r2 == ResultState.Bottom)
-                    yield return nameof(next);
-            }
-        }
-        
-        if (result.IsFailure)
-        {
-            error += result.Error;
-        }
-        if (next.IsFailure)
-        {
-            error += next.Error;
-        }
-        return error is null
-            ? new(null)
-            : new(error);
-    }
-
-    #endregion
-
-    #region <T>
-
-    [Pure] public static Result<T> Append<T>(this in Result result, T value)
-    {
-        return result.State switch
-        {
-            ResultState.Success => value,
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure] public static Result<T> Append<T>(this in Result result, Result<T> next)
-    {
-        Error? error = null;
-
-        if ((result.State & next.State) == ResultState.Bottom)
-        {
-            throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
-
-            static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
-            {
-                if (r1 == ResultState.Bottom)
-                    yield return nameof(result);
-                if (r2 == ResultState.Bottom)
-                    yield return nameof(next);
-            }
-        }
-        
-        if (result.IsFailure)
-        {
-            error += result.Error;
-        }
-        if (next.IsFailure)
-        {
-            error += next.Error;
-        }
-        return error is null
-            ? new(next.Value)
-            : new(error);
-    }
-    [Pure] public static Result<T> Append<T>(this in Result<T> result, Result next)
-    {
-        Error? error = null;
-
-        if ((result.State & next.State) == ResultState.Bottom)
-        {
-            throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
-
-            static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
-            {
-                if (r1 == ResultState.Bottom)
-                    yield return nameof(result);
-                if (r2 == ResultState.Bottom)
-                    yield return nameof(next);
-            }
-        }
-        
-        if (result.IsFailure)
-        {
-            error += result.Error;
-        }
-        if (next.IsFailure)
-        {
-            error += next.Error;
-        }
-        return error is null
-            ? new(result.Value)
-            : new(error);
-    }
-    [Pure]
-    public static Result<T> Append<T>(this in Result result, Func<Result<T>> next)
-    {
-        return result.State switch
-        {
-            ResultState.Success => next(),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-
-    [Pure]
-    public static Task<Result<T>> Append<T>(this in Result result, Func<Task<Result<T>>> next)
-    {
-        return result.State switch
-        {
-            ResultState.Success => next(),
-            ResultState.Error => Task.FromResult<Result<T>>(result.Error!),
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure]
-    public static async Task<Result<T>> Append<T>(this Task<Result> resultTask, Func<Task<Result<T>>> next)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => await next().ConfigureAwait(false),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-    [Pure]
-    public static async Task<Result<T>> Append<T>(this Task<Result> resultTask, Func<Result<T>> next)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => next(),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-
-    #endregion
-
-    #region <T1, T2>
-
-    [Pure] public static Result<(T1, T2)> Append<T1, T2>(this in Result<T1> result, T2 value)
-    {
-        return result.State switch
-        {
-            ResultState.Success => (result.Value, value),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure] public static Result<(T1, T2)> Append<T1, T2>(this in Result<T1> result, Result<T2> next)
-    {
-        Error? error = null;
-
-        if ((result.State & next.State) == ResultState.Bottom)
-        {
-            throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
-
-            static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
-            {
-                if (r1 == ResultState.Bottom)
-                    yield return nameof(result);
-                if (r2 == ResultState.Bottom)
-                    yield return nameof(next);
-            }
-        }
-        
-        if (result.IsFailure)
-        {
-            error += result.Error;
-        }
-        if (next.IsFailure)
-        {
-            error += next.Error;
-        }
-        return error is null
-            ? new((result.Value, next.Value))
-            : new(error);
-    }
-    [Pure] public static Result<(T1, T2)> Append<T1, T2>(this in Result<(T1, T2)> result, Result next)
-    {
-        Error? error = null;
-
-        if ((result.State & next.State) == ResultState.Bottom)
-        {
-            throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
-
-            static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
-            {
-                if (r1 == ResultState.Bottom)
-                    yield return nameof(result);
-                if (r2 == ResultState.Bottom)
-                    yield return nameof(next);
-            }
-        }
-        
-        if (result.IsFailure)
-        {
-            error += result.Error;
-        }
-        if (next.IsFailure)
-        {
-            error += next.Error;
-        }
-        return error is null
-            ? new(result.Value)
-            : new(error);
-    }
-    [Pure]
-    public static Result<(T1, T2)> Append<T1, T2>(this in Result<T1> result, Func<Result<T2>> next)
-    {
-        return result.State switch
-        {
-            ResultState.Success => result.Append(next()),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure]
-    public static async Task<Result<(T1, T2)>> Append<T1, T2>(this Result<T1> result, Func<Task<Result<T2>>> next)
-    {
-        return result.State switch
-        {
-            ResultState.Success => result.Append(await next().ConfigureAwait(false)),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure]
-    public static async Task<Result<(T1, T2)>> Append<T1, T2>(this Task<Result<T1>> resultTask, Func<Task<Result<T2>>> next)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => result.Append(await next().ConfigureAwait(false)),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-    [Pure]
-    public static async Task<Result<(T1, T2)>> Append<T1, T2>(this Task<Result<T1>> resultTask, Func<Result<T2>> next)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => result.Append(next()),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-
-    #endregion
-
-    #region <T1, T2, T3>
-
-    [Pure] public static Result<(T1, T2, T3)> Append<T1, T2, T3>(this in Result<(T1, T2)> result, T3 value)
-    {
-        return result.State switch
-        {
-            ResultState.Success => (result.Value.Item1, result.Value.Item2, value),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure] public static Result<(T1, T2, T3)> Append<T1, T2, T3>(this in Result<(T1, T2)> result, Result<T3> next)
-    {
-        Error? error = null;
-
-        if ((result.State & next.State) == ResultState.Bottom)
-        {
-            throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
-
-            static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
-            {
-                if (r1 == ResultState.Bottom)
-                    yield return nameof(result);
-                if (r2 == ResultState.Bottom)
-                    yield return nameof(next);
-            }
-        }
-        
-        if (result.IsFailure)
-        {
-            error += result.Error;
-        }
-        if (next.IsFailure)
-        {
-            error += next.Error;
-        }
-        return error is null
-            ? new((result.Value.Item1, result.Value.Item2, next.Value))
-            : new(error);
-    }
-    [Pure] public static Result<(T1, T2, T3)> Append<T1, T2, T3>(this in Result<(T1, T2, T3)> result, Result next)
-    {
-        Error? error = null;
-
-        if ((result.State & next.State) == ResultState.Bottom)
-        {
-            throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
-
-            static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
-            {
-                if (r1 == ResultState.Bottom)
-                    yield return nameof(result);
-                if (r2 == ResultState.Bottom)
-                    yield return nameof(next);
-            }
-        }
-        
-        if (result.IsFailure)
-        {
-            error += result.Error;
-        }
-        if (next.IsFailure)
-        {
-            error += next.Error;
-        }
-        return error is null
-            ? new(result.Value)
-            : new(error);
-    }
-    [Pure]
-    public static Result<(T1, T2, T3)> Append<T1, T2, T3>(this in Result<(T1, T2)> result, Func<Result<T3>> next)
-    {
-        return result.State switch
-        {
-            ResultState.Success => result.Append(next()),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure]
-    public static async Task<Result<(T1, T2, T3)>> Append<T1, T2, T3>(this Result<(T1, T2)> result, Func<Task<Result<T3>>> next)
-    {
-        return result.State switch
-        {
-            ResultState.Success => result.Append(await next().ConfigureAwait(false)),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure]
-    public static async Task<Result<(T1, T2, T3)>> Append<T1, T2, T3>(this Task<Result<(T1, T2)>> resultTask, Func<Task<Result<T3>>> next)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => result.Append(await next().ConfigureAwait(false)),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-    [Pure]
-    public static async Task<Result<(T1, T2, T3)>> Append<T1, T2, T3>(this Task<Result<(T1, T2)>> resultTask, Func<Result<T3>> next)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => result.Append(next()),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-
-    #endregion
-
-    #region <T1, T2, T3, T4>
-
-    [Pure] public static Result<(T1, T2, T3, T4)> Append<T1, T2, T3, T4>(this in Result<(T1, T2, T3)> result, T4 value)
-    {
-        return result.State switch
-        {
-            ResultState.Success => (result.Value.Item1, result.Value.Item2, result.Value.Item3, value),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure] public static Result<(T1, T2, T3, T4)> Append<T1, T2, T3, T4>(this in Result<(T1, T2, T3)> result, Result<T4> next)
-    {
-        Error? error = null;
-
-        if ((result.State & next.State) == ResultState.Bottom)
-        {
-            throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
-
-            static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
-            {
-                if (r1 == ResultState.Bottom)
-                    yield return nameof(result);
-                if (r2 == ResultState.Bottom)
-                    yield return nameof(next);
-            }
-        }
-        
-        if (result.IsFailure)
-        {
-            error += result.Error;
-        }
-        if (next.IsFailure)
-        {
-            error += next.Error;
-        }
-        return error is null
-            ? new((result.Value.Item1, result.Value.Item2, result.Value.Item3, next.Value))
-            : new(error);
-    }
-    [Pure] public static Result<(T1, T2, T3, T4)> Append<T1, T2, T3, T4>(this in Result<(T1, T2, T3, T4)> result, Result next)
-    {
-        Error? error = null;
-
-        if ((result.State & next.State) == ResultState.Bottom)
-        {
-            throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
-
-            static IEnumerable<string> GetBottom(ResultState r1, ResultState r2)
-            {
-                if (r1 == ResultState.Bottom)
-                    yield return nameof(result);
-                if (r2 == ResultState.Bottom)
-                    yield return nameof(next);
-            }
-        }
-        
-        if (result.IsFailure)
-        {
-            error += result.Error;
-        }
-        if (next.IsFailure)
-        {
-            error += next.Error;
-        }
-        return error is null
-            ? new(result.Value)
-            : new(error);
-    }
-    [Pure]
-    public static Result<(T1, T2, T3, T4)> Append<T1, T2, T3, T4>(this in Result<(T1, T2, T3)> result, Func<Result<T4>> next)
-    {
-        return result.State switch
-        {
-            ResultState.Success => result.Append(next()),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure]
-    public static async Task<Result<(T1, T2, T3, T4)>> Append<T1, T2, T3, T4>(this Result<(T1, T2, T3)> result, Func<Task<Result<T4>>> next)
-    {
-        return result.State switch
-        {
-            ResultState.Success => result.Append(await next().ConfigureAwait(false)),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(result))
-        };
-    }
-    [Pure]
-    public static async Task<Result<(T1, T2, T3, T4)>> Append<T1, T2, T3, T4>(this Task<Result<(T1, T2, T3)>> resultTask, Func<Task<Result<T4>>> next)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => result.Append(await next().ConfigureAwait(false)),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-    [Pure]
-    public static async Task<Result<(T1, T2, T3, T4)>> Append<T1, T2, T3, T4>(this Task<Result<(T1, T2, T3)>> resultTask, Func<Result<T4>> next)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        return result.State switch
-        {
-            ResultState.Success => result.Append(next()),
-            ResultState.Error => result.Error!,
-            _ => throw new ResultNotInitializedException(nameof(resultTask))
-        };
-    }
-
-    #endregion
-
-    #endregion
-
-    #region Tap<>
-    [Pure]
-    public static ref readonly Result Tap(this in Result result, Action? onSuccess = null, Action<Error>? onFailure = null)
-    {
-        switch (result.State)
-        {
-            case ResultState.Success:
-                onSuccess?.Invoke();
-                break;
-            case ResultState.Error:
-                onFailure?.Invoke(result.Error!);
-                break;
-
-            default: throw new ResultNotInitializedException(nameof(result));
-        }
-
-        return ref result;
-    }
-    [Pure]
-    public static async Task<Result> Tap(this Task<Result> resultTask, Action? onSuccess = null, Action<Error>? onFailure = null)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        switch (result.State)
-        {
-            case ResultState.Success:
-                onSuccess?.Invoke();
-                break;
-            case ResultState.Error:
-                onFailure?.Invoke(result.Error!);
-                break;
-
-            default: throw new ResultNotInitializedException(nameof(resultTask));
-        }
-
-        return result;
-    }
-    [Pure]
-    public static async Task<Result> Tap(this Result result, Func<Task>? onSuccess = null, Func<Error, Task>? onFailure = null)
-    {
-        switch (result.State)
-        {
-            case ResultState.Success:
-                if (onSuccess is not null)
-                    await onSuccess.Invoke().ConfigureAwait(false);
-                break;
-            case ResultState.Error:
-                if (onFailure is not null)
-                    await onFailure.Invoke(result.Error!).ConfigureAwait(false);
-                break;
-
-            default: throw new ResultNotInitializedException(nameof(result));
-        }
-
-        return result;
-    }
-    [Pure]
-    public static async Task<Result> Tap(this Task<Result> resultTask, Func<Task>? onSuccess = null, Func<Error, Task>? onFailure = null)
-    {
-        var result = await resultTask.ConfigureAwait(false);
-        switch (result.State)
-        {
-            case ResultState.Success:
-                if (onSuccess is not null)
-                    await onSuccess.Invoke().ConfigureAwait(false);
-                break;
-            case ResultState.Error:
-                if (onFailure is not null)
-                    await onFailure.Invoke(result.Error!).ConfigureAwait(false);
-                break;
-
-            default: throw new ResultNotInitializedException(nameof(resultTask));
-        }
-
-        return result;
-    }
-
-#endregion
-
     #region Merge
 
+    public static Result Merge(this IEnumerable<Result> results)
+    {
+        List<Error>? errors = null;
+        bool hasErrors = false;
+
+        foreach (var result in results.OrderBy(x => x.State))
+        {
+            switch (result.State)
+            {
+                case ResultState.Error:
+                    hasErrors = true;
+                    errors ??= [];
+                    errors.Add(result.Error!);
+                    break;
+
+                case ResultState.Success:
+                    if (hasErrors) goto afterLoop;
+                    break;
+                    
+                default: throw new ResultNotInitializedException(nameof(results));
+            }
+        }
+        afterLoop:
+        return hasErrors
+            ? new(new ManyErrors(errors!))
+            : new(null);
+    }
+    public static async Task<Result> Merge(this IEnumerable<Task<Result>> tasks)
+    {
+        var results = await Task.WhenAll(tasks).ConfigureAwait(false);
+        return results.Merge();
+    }
+
     public static Result<IEnumerable<T>> Merge<T>(this IEnumerable<Result<T>> results)
     {
         List<T>? values = null;