made all extensions source generated

2023-12-07 23:21:00 +04:00
parent b79192ec6c
commit f39b899514
12 changed files with 675 additions and 899 deletions
--- a/Railway.SourceGenerator/Constants.cs
+++ b/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;
 }
--- a/Railway.SourceGenerator/ResultAppendExecutor.cs
+++ b/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}"
+    };
+}
--- a/Railway.SourceGenerator/ResultBindExecutor.cs
+++ b/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");
    }
 }
--- a/Railway.SourceGenerator/ResultCombineExecutor.cs
+++ b/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)
--- a/Railway.SourceGenerator/ResultExtensionsExecutor.cs
+++ b/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) {}
 }
--- a/Railway.SourceGenerator/ResultMapExecutor.cs
+++ b/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))
+            };
+        }
+        """);
+    }
 }
--- a/Railway.SourceGenerator/ResultMatchExecutor.cs
+++ b/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");
    }
 }
--- a/Railway.SourceGenerator/ResultMethodGenerator.cs
+++ b/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)
--- a/Railway.SourceGenerator/ResultTapExecutor.cs
+++ b/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");
    }
 }