extensions rework pt1

2026-07-13 22:20:47 +04:00
parent 46487a4794
commit 0e7986996f
30 changed files with 1476 additions and 160 deletions
@@ -0,0 +1,463 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.MainExtensions;
+
+internal class ResultAppendExecutor : ResultExtensionsExecutor
+{
+    protected override string ExtensionType => "Append";
+    protected override string NamespaceName => "Just.Railway";
+    protected override string PartialClassName => "ResultExtensions";
+
+    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", string.Empty, sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        if (argCount < Constants.MaxResultTupleSize)
+        {
+            GenerateExpandedMethods(sb, templateArgNames, resultTypeDef, resultValueExpansion);
+            GenerateExpandedAsyncMethods("Task", string.Empty, sb, templateArgNames, resultTypeDef, resultValueExpansion);
+        }
+
+        sb.AppendLine("#endregion");
+    }
+
+    protected static void GenerateAsyncMethods(string taskType, string methodSuffix, 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{{methodSuffix}}{{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{{methodSuffix}}{{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{{methodSuffix}}{{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}});
+        }
+        """);
+    }
+
+    protected static void GenerateExpandedAsyncMethods(string taskType, string methodSuffix, 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{{methodSuffix}}{{methodExpandedTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, TNext next)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            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 async {{taskType}}<{{resultExpandedTypeDef}}> Append{{methodSuffix}}{{methodExpandedTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Result<TNext> next)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            if ((result.State & next.State) == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(string.Join(';', GetBottom(result.State, next.State)));
+            }
+
+            Error? error = null;
+            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 async {{taskType}}<{{resultExpandedTypeDef}}> Append{{methodSuffix}}{{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{{methodSuffix}}{{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{{methodSuffix}}{{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{{methodSuffix}}{{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{{methodSuffix}}{{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{{methodSuffix}}{{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")}});
+        }
+        """);
+    }
+}
@@ -0,0 +1,96 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.MainExtensions;
+
+internal class ResultBindExecutor : ResultExtensionsExecutor
+{
+    protected override string ExtensionType => "Bind";
+    protected override string NamespaceName => "Just.Railway";
+    protected override string PartialClassName => "ResultExtensions";
+
+    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.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{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Func{{bindTemplateDecl}} binding)
+        {
+            return result.State switch
+            {
+                ResultState.Success => binding({{resultValueExpansion}}),
+                ResultState.Error => result.Error!,
+                _ => throw new ResultNotInitializedException(nameof(result))
+            };
+        }
+        """);
+
+        GenerateAsyncMethods("Task", string.Empty, sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        sb.AppendLine("#endregion");
+    }
+
+    protected static void GenerateAsyncMethods(string taskType, string methodSuffix, 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 {{taskType}}<Result<R>> Bind{{methodSuffix}}{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{bindTemplateDecl}} binding)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            return result.State switch
+            {
+                ResultState.Success => binding({{resultValueExpansion}}),
+                ResultState.Error => result.Error!,
+                _ => throw new ResultNotInitializedException(nameof(resultTask))
+            };
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultBindExecutor)}}", "1.0.0.0")]
+        public static {{taskType}}<Result<R>> Bind{{methodSuffix}}{{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{{methodSuffix}}{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{asyncActionTemplateDecl}} binding)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            return result.State switch
+            {
+                ResultState.Success => await binding({{resultValueExpansion}}).ConfigureAwait(false),
+                ResultState.Error => result.Error!,
+                _ => throw new ResultNotInitializedException(nameof(resultTask))
+            };
+        }
+        """);
+    }
+}
@@ -0,0 +1,196 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.MainExtensions;
+
+internal sealed class ResultCombineExecutor : IGeneratorExecutor
+{
+    public void Execute(IncrementalGeneratorPostInitializationContext context)
+    {
+        var methods = GenerateCombineMethods();
+        var code = $$"""
+        #nullable enable
+        using System;
+        using System.Collections.Generic;
+        using System.Diagnostics.Contracts;
+        using System.CodeDom.Compiler;
+
+        namespace Just.Railway;
+
+        public readonly partial struct Result
+        {
+        {{methods}}
+        }
+        """;
+
+        context.AddSource("Result.Combine.g.cs", code);
+    }
+
+
+    private string GenerateCombineMethods()
+    {
+        var sb = new StringBuilder();
+
+        for (int i = 2; i <= Constants.MaxResultTupleSize; i++)
+        {
+            GenerateCombineMethodsForArgCount(sb, argCount: i);
+        }
+
+        return sb.ToString();
+    }
+
+    private void GenerateCombineMethodsForArgCount(StringBuilder sb, int argCount)
+    {
+        sb.AppendLine($"#region Combine {argCount} Results");
+
+        GenerateGetBottomMethod(sb, argCount);
+
+        var permutations = 1 << argCount;
+        var argsResultTupleSizes = new ImmutableArray<int>[permutations];
+
+        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)
+        {
+            sb.AppendLine(GenerateCombineMethodBody(argResultTupleSizes));
+        }
+
+        sb.AppendLine("#endregion");
+
+    }
+
+    private static void GenerateGetBottomMethod(StringBuilder sb, int argCount)
+    {
+        var args = Enumerable.Range(1, argCount)
+            .Select(i => $"result{i}")
+            .ToImmutableArray();
+        var argsDecl = string.Join(", ", args.Select(x => $"ResultState {x}"));
+        sb.AppendLine($"[GeneratedCodeAttribute(\"{nameof(ResultCombineExecutor)}\", \"1.0.0.0\")]");
+        sb.AppendLine($"private static IEnumerable<string> GetBottom({argsDecl})");
+        sb.AppendLine("{");
+        foreach (var arg in args)
+        {
+            sb.AppendLine($"    if ({arg} == ResultState.Bottom) yield return \"{arg}\";");
+        }
+        sb.AppendLine("}");
+    }
+
+    private string GenerateCombineMethodBody(ImmutableArray<int> argResultTupleSizes)
+    {
+        var resultTupleSize = argResultTupleSizes.Sum();
+
+        var paramNames = Enumerable.Range(1, argResultTupleSizes.Length)
+            .Select(i => $"result{i}")
+            .ToImmutableArray();
+        var templateArgNames = Enumerable.Range(1, resultTupleSize)
+            .Select(i => $"T{i}")
+            .ToImmutableArray();
+
+        string templateDecl = templateArgNames.IsEmpty 
+            ? string.Empty
+            : $"<{string.Join(", ", templateArgNames)}>";
+        string resultTypeDecl = GetResultTypeDecl(templateArgNames);
+        string paramDecl;
+        {
+            var paramDeclBuilder = new StringBuilder();
+            int currentTemplateArg = 0;
+            for (int i = 0; i < argResultTupleSizes.Length; i++)
+            {
+                var argResultTupleSize = argResultTupleSizes[i];
+                string currentParamType = GetResultTypeDecl(templateArgNames.Slice(currentTemplateArg, argResultTupleSize));
+                currentTemplateArg += argResultTupleSize;
+                paramDeclBuilder.Append($"in {currentParamType} {paramNames[i]}, ");
+            }
+            paramDeclBuilder.Remove(paramDeclBuilder.Length-2, 2);
+            paramDecl = paramDeclBuilder.ToString();
+        }
+
+        var paramNameStates = paramNames.Select(x => $"{x}.State")
+            .ToImmutableArray();
+        string bottomStateCheck = string.Join(" & ", paramNameStates);
+        string statesSeparatedList = string.Join(", ", paramNameStates);
+
+        string failureChecks;
+        {
+            var failureChecksBuilder = new StringBuilder();
+            foreach (var paramName in paramNames)
+            {
+                failureChecksBuilder.AppendLine($"    if ({paramName}.IsFailure) error += {paramName}.Error;");
+            }
+            failureChecks = failureChecksBuilder.ToString();
+        }
+        string resultExpansion;
+        switch (resultTupleSize)
+        {
+            case 0:
+            resultExpansion = "null";
+            break;
+
+            case 1:
+            resultExpansion = $"{paramNames[argResultTupleSizes.IndexOf(1)]}.Value";
+            break;
+            
+            default:
+            var resultExpansionBuilder = new StringBuilder();
+            resultExpansionBuilder.Append("(");
+            for (int i = 0; i < argResultTupleSizes.Length; i++)
+            {
+                if (argResultTupleSizes[i] == 0) continue;
+                if (argResultTupleSizes[i] == 1)
+                {
+                    resultExpansionBuilder.Append($"{paramNames[i]}.Value, ");
+                    continue;
+                }
+                
+                for (int valueIndex = 1; valueIndex <= argResultTupleSizes[i]; valueIndex++)
+                {
+                    resultExpansionBuilder.Append($"{paramNames[i]}.Value.Item{valueIndex}, ");
+                }
+            }
+            resultExpansionBuilder.Remove(resultExpansionBuilder.Length - 2, 2);
+            resultExpansionBuilder.Append(")");
+            resultExpansion = resultExpansionBuilder.ToString();
+            break;
+        }
+        
+        string returnExpr = $"return error is null ? new({resultExpansion}) : new(error);";
+        var method = $$"""
+        [GeneratedCodeAttribute("{{nameof(ResultCombineExecutor)}}", "1.0.0.0")]
+        [PureAttribute]
+        public static {{resultTypeDecl}} Combine{{templateDecl}}({{paramDecl}})
+        {
+            if (({{bottomStateCheck}}) == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(string.Join(';', GetBottom({{statesSeparatedList}})));
+            }
+            Error? error = null;
+        {{failureChecks}}
+            {{returnExpr}}
+        }
+        """;
+        return method;
+
+        static string GetResultTypeDecl(IReadOnlyList<string> templateArgNames)
+        {
+            return templateArgNames.Count switch
+            {
+                0 => "Result",
+                1 => $"Result<{templateArgNames[0]}>",
+                _ => $"Result<({string.Join(", ", templateArgNames)})>"
+            };
+        }
+    }
+}
@@ -0,0 +1,161 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.MainExtensions;
+
+internal class ResultExtendExecutor : ResultExtensionsExecutor
+{
+    protected override string ExtensionType => "Extend";
+    protected override string NamespaceName => "Just.Railway";
+    protected override string PartialClassName => "ResultExtensions";
+
+    protected override void GenerateMethodsForArgCount(StringBuilder sb, int argCount)
+    {
+        if (argCount == 0 || argCount == Constants.MaxResultTupleSize)
+        {
+            return;
+        }
+
+        var templateArgNames = Enumerable.Range(1, argCount)
+            .Select(i => $"T{i}")
+            .ToImmutableArray();
+
+        var expandedTemplateArgNames = templateArgNames.Add("R");
+        string resultTypeDef = GenerateResultTypeDef(templateArgNames);
+        string resultValueExpansion = GenerateResultValueExpansion(templateArgNames);
+        string resultExpandedTypeDef = GenerateResultTypeDef(expandedTemplateArgNames);
+        string methodTemplateDecl = GenerateTemplateDecl(expandedTemplateArgNames);
+        string bindTemplateDecl = GenerateTemplateDecl(templateArgNames.Add("Result<R>"));
+
+        sb.AppendLine($"#region {resultTypeDef}");
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultExtendExecutor)}}", "1.0.0.0")]
+        public static {{resultExpandedTypeDef}} Extend{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Func{{bindTemplateDecl}} extensionFunc)
+        {
+            if (result.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(result));
+            }
+            else if (result.IsFailure)
+            {
+                return result.Error!;
+            }
+
+            var extension = extensionFunc({{resultValueExpansion}});
+            if (extension.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(extensionFunc));
+            }
+            else if (extension.IsFailure)
+            {
+                return extension.Error!;
+            }
+
+            return Result.Success({{JoinArguments(resultValueExpansion, "extension.Value")}});
+        }
+        """);
+
+        GenerateAsyncMethods("Task", string.Empty, sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        sb.AppendLine("#endregion");
+    }
+
+    protected static void GenerateAsyncMethods(string taskType, string methodSuffix, StringBuilder sb, ImmutableArray<string> templateArgNames, string resultTypeDef, string resultValueExpansion)
+    {
+        var expandedTemplateArgNames = templateArgNames.Add("R");
+        string resultExpandedTypeDef = GenerateResultTypeDef(expandedTemplateArgNames);
+        string methodTemplateDecl = GenerateTemplateDecl(expandedTemplateArgNames);
+        string bindTemplateDecl = GenerateTemplateDecl(templateArgNames.Add("Result<R>"));
+        string asyncActionTemplateDecl = GenerateTemplateDecl(templateArgNames.Add($"{taskType}<Result<R>>"));
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultExtendExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultExpandedTypeDef}}> Extend{{methodSuffix}}{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{bindTemplateDecl}} extensionFunc)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            if (result.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(resultTask));
+            }
+            else if (result.IsFailure)
+            {
+                return result.Error!;
+            }
+
+            var extension = extensionFunc({{resultValueExpansion}});
+            if (extension.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(extensionFunc));
+            }
+            else if (extension.IsFailure)
+            {
+                return extension.Error!;
+            }
+
+            return Result.Success({{JoinArguments(resultValueExpansion, "extension.Value")}});
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultExtendExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultExpandedTypeDef}}> Extend{{methodSuffix}}{{methodTemplateDecl}}(this {{resultTypeDef}} result, Func{{asyncActionTemplateDecl}} extensionFunc)
+        {
+            if (result.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(result));
+            }
+            else if (result.IsFailure)
+            {
+                return result.Error!;
+            }
+
+            var extension = await extensionFunc({{resultValueExpansion}}).ConfigureAwait(false);
+            if (extension.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(extensionFunc));
+            }
+            else if (extension.IsFailure)
+            {
+                return extension.Error!;
+            }
+
+            return Result.Success({{JoinArguments(resultValueExpansion, "extension.Value")}});
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultExtendExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultExpandedTypeDef}}> Extend{{methodSuffix}}{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{asyncActionTemplateDecl}} extensionFunc)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            if (result.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(resultTask));
+            }
+            else if (result.IsFailure)
+            {
+                return result.Error!;
+            }
+
+            var extension = await extensionFunc({{resultValueExpansion}}).ConfigureAwait(false);
+            if (extension.State == ResultState.Bottom)
+            {
+                throw new ResultNotInitializedException(nameof(extensionFunc));
+            }
+            else if (extension.IsFailure)
+            {
+                return extension.Error!;
+            }
+
+            return Result.Success({{JoinArguments(resultValueExpansion, "extension.Value")}});
+        }
+        """);
+    }
+}
@@ -0,0 +1,96 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Just.Railway.SourceGen.Executors.ResultExtensions;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors;
+
+internal class ResultMapExecutor : ResultExtensionsExecutor
+{
+    protected override string ExtensionType => "Map";
+    protected override string NamespaceName => "Just.Railway";
+    protected override string PartialClassName => "ResultExtensions";
+
+    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.Add("R"));
+
+        sb.AppendLine($"#region {resultTypeDef}");
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultMapExecutor)}}", "1.0.0.0")]
+        public static Result<R> Map{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Func{{methodTemplateDecl}} mapping)
+        {
+            return result.State switch
+            {
+                ResultState.Success => mapping({{resultValueExpansion}}),
+                ResultState.Error => result.Error!,
+                _ => throw new ResultNotInitializedException(nameof(result))
+            };
+        }
+        """);
+
+        GenerateAsyncMethods("Task", string.Empty, sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        sb.AppendLine("#endregion");
+    }
+
+    protected static void GenerateAsyncMethods(string taskType, string methodSuffix, 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{{methodSuffix}}{{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{{methodSuffix}}{{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{{methodSuffix}}{{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))
+            };
+        }
+        """);
+    }
+}
@@ -0,0 +1,96 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.MainExtensions;
+
+internal class ResultMatchExecutor : ResultExtensionsExecutor
+{
+    protected override string ExtensionType => "Match";
+    protected override string NamespaceName => "Just.Railway";
+    protected override string PartialClassName => "ResultExtensions";
+
+    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.Add("R"));
+
+        sb.AppendLine($"#region {resultTypeDef}");
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultMatchExecutor)}}", "1.0.0.0")]
+        public static R Match{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Func{{methodTemplateDecl}} onSuccess, Func<Error, R> onFailure)
+        {
+            return result.State switch
+            {
+                ResultState.Success => onSuccess({{resultValueExpansion}}),
+                ResultState.Error => onFailure(result.Error!),
+                _ => throw new ResultNotInitializedException(nameof(result))
+            };
+        }
+        """);
+
+        GenerateAsyncMethods("Task", string.Empty, sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        sb.AppendLine("#endregion");
+    }
+
+    protected static void GenerateAsyncMethods(string taskType, string methodSuffix, 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 {{taskType}}<R> Match{{methodSuffix}}{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{methodTemplateDecl}} onSuccess, Func<Error, R> onFailure)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            return result.State switch
+            {
+                ResultState.Success => onSuccess({{resultValueExpansion}}),
+                ResultState.Error => onFailure(result.Error!),
+                _ => throw new ResultNotInitializedException(nameof(resultTask))
+            };
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultMatchExecutor)}}", "1.0.0.0")]
+        public static {{taskType}}<R> Match{{methodSuffix}}{{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{{methodSuffix}}{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{asyncActionTemplateDecl}} onSuccess, Func<Error, {{taskType}}<R>> onFailure)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            var matchTask = result.State switch
+            {
+                ResultState.Success => onSuccess({{resultValueExpansion}}),
+                ResultState.Error => onFailure(result.Error!),
+                _ => throw new ResultNotInitializedException(nameof(resultTask))
+            };
+            return await matchTask.ConfigureAwait(false);
+        }
+        """);
+    }
+}
@@ -0,0 +1,122 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.MainExtensions;
+
+internal class ResultTapExecutor : ResultExtensionsExecutor
+{
+    protected override string ExtensionType => "Tap";
+    protected override string NamespaceName => "Just.Railway";
+    protected override string PartialClassName => "ResultExtensions";
+
+    protected override void GenerateMethodsForArgCount(StringBuilder sb, int argCount)
+    {
+        var templateArgNames = Enumerable.Range(1, argCount)
+            .Select(i => $"T{i}")
+            .ToImmutableArray();
+
+        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 {{resultTypeDef}} Tap{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Action{{methodTemplateDecl}}? onSuccess = null, Action<Error>? onFailure = null)
+        {
+            switch (result.State)
+            {
+                case ResultState.Success:
+                    onSuccess?.Invoke({{resultValueExpansion}});
+                    break;
+                case ResultState.Error:
+                    onFailure?.Invoke(result.Error!);
+                    break;
+
+                default: throw new ResultNotInitializedException(nameof(result));
+            }
+            return result;
+        }
+        """);
+
+        GenerateAsyncMethods("Task", string.Empty, sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        sb.AppendLine("#endregion");
+    }
+
+    protected static void GenerateAsyncMethods(string taskType, string methodSuffix, 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 {{taskType}}<{{resultTypeDef}}> Tap{{methodSuffix}}{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Action{{methodTemplateDecl}}? onSuccess = null, Action<Error>? onFailure = null)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            switch (result.State)
+            {
+                case ResultState.Success:
+                    onSuccess?.Invoke({{resultValueExpansion}});
+                    break;
+                case ResultState.Error:
+                    onFailure?.Invoke(result.Error!);
+                    break;
+
+                default: throw new ResultNotInitializedException(nameof(resultTask));
+            }
+            return result;
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultTapExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultTypeDef}}> Tap{{methodSuffix}}{{methodTemplateDecl}}(this {{resultTypeDef}} result, Func{{asyncActionTemplateDecl}}? onSuccess = null, Func<Error, {{taskType}}>? onFailure = null)
+        {
+            switch (result.State)
+            {
+                case ResultState.Success:
+                    if (onSuccess is not null)
+                        await onSuccess.Invoke({{resultValueExpansion}}).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;
+        }
+        """);
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultTapExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultTypeDef}}> Tap{{methodSuffix}}{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func{{asyncActionTemplateDecl}}? onSuccess = null, Func<Error, {{taskType}}>? onFailure = null)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            switch (result.State)
+            {
+                case ResultState.Success:
+                    if (onSuccess is not null)
+                        await onSuccess.Invoke({{resultValueExpansion}}).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;
+        }
+        """);
+    }
+}
@@ -0,0 +1,88 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.MainExtensions;
+
+internal class ResultTryRecoverExecutor : ResultExtensionsExecutor
+{
+    protected override string ExtensionType => "TryRecover";
+    protected override string NamespaceName => "Just.Railway";
+    protected override string PartialClassName => "ResultExtensions";
+
+    protected override void GenerateMethodsForArgCount(StringBuilder sb, int argCount)
+    {
+        if (argCount > 1) return;
+
+        var templateArgNames = Enumerable.Repeat("T", argCount)
+            .ToImmutableArray();
+
+        string methodTemplateDecl = GenerateTemplateDecl(templateArgNames);
+        string resultTypeDef = GenerateResultTypeDef(templateArgNames);
+
+        sb.AppendLine($"#region {resultTypeDef}");
+
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultTryRecoverExecutor)}}", "1.0.0.0")]
+        public static {{resultTypeDef}} TryRecover{{methodTemplateDecl}}(this in {{resultTypeDef}} result, Func<Error, {{resultTypeDef}}> recover)
+        {
+            return result.State switch
+            {
+                ResultState.Success => ({{resultTypeDef}})result.Value,
+                ResultState.Error => recover(result.Error!),
+                _ => throw new ResultNotInitializedException(nameof(result))
+            };
+        }
+        """);
+
+        GenerateAsyncMethods("Task", string.Empty, sb, templateArgNames, resultTypeDef, methodTemplateDecl);
+
+        sb.AppendLine("#endregion");
+    }
+
+    protected static void GenerateAsyncMethods(string taskType, string methodSuffix, StringBuilder sb, ImmutableArray<string> templateArgNames, string resultTypeDef, string methodTemplateDecl)
+    {
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultTryRecoverExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultTypeDef}}> TryRecover{{methodSuffix}}{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func<Error, {{resultTypeDef}}> recover)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            return result.State switch
+            {
+                ResultState.Success => ({{resultTypeDef}})result.Value,
+                ResultState.Error => recover(result.Error!),
+                _ => throw new ResultNotInitializedException(nameof(resultTask))
+            };
+        }
+        """);
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultTryRecoverExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultTypeDef}}> TryRecover{{methodSuffix}}{{methodTemplateDecl}}(this {{resultTypeDef}} result, Func<Error, {{taskType}}<{{resultTypeDef}}>> recover)
+        {
+            return result.State switch
+            {
+                ResultState.Success => ({{resultTypeDef}})result.Value,
+                ResultState.Error => await recover(result.Error!).ConfigureAwait(false),
+                _ => throw new ResultNotInitializedException(nameof(result))
+            };
+        }
+        """);
+        sb.AppendLine($$"""
+        [PureAttribute]
+        [GeneratedCodeAttribute("{{nameof(ResultTryRecoverExecutor)}}", "1.0.0.0")]
+        public static async {{taskType}}<{{resultTypeDef}}> TryRecover{{methodSuffix}}{{methodTemplateDecl}}(this {{taskType}}<{{resultTypeDef}}> resultTask, Func<Error, {{taskType}}<{{resultTypeDef}}>> recover)
+        {
+            var result = await resultTask.ConfigureAwait(false);
+            return result.State switch
+            {
+                ResultState.Success => ({{resultTypeDef}})result.Value,
+                ResultState.Error => await recover(result.Error!).ConfigureAwait(false),
+                _ => throw new ResultNotInitializedException(nameof(resultTask))
+            };
+        }
+        """);
+    }
+}
@@ -0,0 +1,94 @@
+using System.Collections.Immutable;
+using System.Text;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions;
+
+internal abstract class ResultExtensionsExecutor : IGeneratorExecutor
+{
+    public void Execute(IncrementalGeneratorPostInitializationContext context)
+    {
+        var methods = GenerateMethods();
+        var code = $$"""
+        #nullable enable
+        using System;
+        using System.Collections.Generic;
+        using System.Diagnostics.Contracts;
+        using System.CodeDom.Compiler;
+
+        namespace {{NamespaceName}};
+
+        public static partial class {{PartialClassName}}
+        {
+        {{methods}}
+        }
+        """;
+
+        context.AddSource($"{PartialClassName}.{ExtensionType}.g.cs", code);
+    }
+
+    private string GenerateMethods()
+    {
+        var sb = new StringBuilder();
+
+        GenerateHelperMethods(sb);
+        for (int i = 0; i <= Constants.MaxResultTupleSize; i++)
+        {
+            GenerateMethodsForArgCount(sb, argCount: i);
+        }
+
+        return sb.ToString();
+    }
+
+    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 JoinArguments(string arg1, string arg2) => (arg1, arg2) switch
+    {
+        ("", "") => "",
+        (string arg, "") => arg,
+        ("", string arg) => arg,
+        _ => $"{arg1}, {arg2}"
+    };
+
+    protected static string GenerateResultValueExpansion(ImmutableArray<string> templateArgNames)
+    {
+        string resultExpansion;
+
+        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++)
+            {
+                resultExpansionBuilder.Append($"result.Value.Item{i}, ");
+            }
+            resultExpansionBuilder.Remove(resultExpansionBuilder.Length - 2, 2);
+            resultExpansion = resultExpansionBuilder.ToString();
+            break;
+        }
+
+        return resultExpansion;
+    }
+
+    protected abstract string ExtensionType { get; }
+    protected abstract string NamespaceName { get; }
+    protected abstract string PartialClassName { get; }
+    protected abstract void GenerateMethodsForArgCount(StringBuilder sb, int argCount);
+    protected virtual void GenerateHelperMethods(StringBuilder sb) {}
+}
@@ -0,0 +1,47 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Just.Railway.SourceGen.Executors.ResultExtensions.MainExtensions;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.ValueTaskExtensions;
+
+internal class ResultValueTaskAppendExecutor : ResultAppendExecutor
+{
+    protected override string NamespaceName => "Just.Railway.ValueTaskExtensions";
+    protected override string PartialClassName => "ResultValueTaskExtensions";
+
+    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);
+
+        sb.AppendLine($"#region {resultTypeDef}");
+
+        GenerateAsyncMethods("ValueTask", "ValueTask", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        if (argCount < Constants.MaxResultTupleSize)
+        {
+            GenerateExpandedAsyncMethods("ValueTask", "ValueTask", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+        }
+
+        sb.AppendLine("#endregion");
+    }
+}
@@ -0,0 +1,29 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Just.Railway.SourceGen.Executors.ResultExtensions.MainExtensions;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.ValueTaskExtensions;
+
+internal class ResultValueTaskBindExecutor : ResultBindExecutor
+{
+    protected override string NamespaceName => "Just.Railway.ValueTaskExtensions";
+    protected override string PartialClassName => "ResultValueTaskExtensions";
+
+    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);
+
+        sb.AppendLine($"#region {resultTypeDef}");
+
+        GenerateAsyncMethods("ValueTask", "ValueTask", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        sb.AppendLine("#endregion");
+    }
+}
@@ -0,0 +1,35 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Just.Railway.SourceGen.Executors.ResultExtensions.MainExtensions;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.ValueTaskExtensions;
+
+internal sealed class ResultValueTaskExtendExecutor : ResultExtendExecutor
+{
+    protected override string NamespaceName => "Just.Railway.ValueTaskExtensions";
+    protected override string PartialClassName => "ResultValueTaskExtensions";
+
+    protected override void GenerateMethodsForArgCount(StringBuilder sb, int argCount)
+    {
+        if (argCount == 0 || argCount == Constants.MaxResultTupleSize)
+        {
+            return;
+        }
+
+        var templateArgNames = Enumerable.Range(1, argCount)
+            .Select(i => $"T{i}")
+            .ToImmutableArray();
+
+        var expandedTemplateArgNames = templateArgNames.Add("R");
+        string resultTypeDef = GenerateResultTypeDef(templateArgNames);
+        string resultValueExpansion = GenerateResultValueExpansion(templateArgNames);
+
+        sb.AppendLine($"#region {resultTypeDef}");
+
+        GenerateAsyncMethods("ValueTask", "ValueTask", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        sb.AppendLine("#endregion");
+    }
+}
@@ -0,0 +1,28 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.ValueTaskExtensions;
+
+internal sealed class ResultValueTaskMapExecutor : ResultMapExecutor
+{
+    protected override string NamespaceName => "Just.Railway.ValueTaskExtensions";
+    protected override string PartialClassName => "ResultValueTaskExtensions";
+
+    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);
+
+        sb.AppendLine($"#region {resultTypeDef}");
+
+        GenerateAsyncMethods("ValueTask", "ValueTask", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        sb.AppendLine("#endregion");
+    }
+}
@@ -0,0 +1,29 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Just.Railway.SourceGen.Executors.ResultExtensions.MainExtensions;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.ValueTaskExtensions;
+
+internal class ResultValueTaskMatchExecutor : ResultMatchExecutor
+{
+    protected override string NamespaceName => "Just.Railway.ValueTaskExtensions";
+    protected override string PartialClassName => "ResultValueTaskExtensions";
+
+    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);
+
+        sb.AppendLine($"#region {resultTypeDef}");
+
+        GenerateAsyncMethods("ValueTask", "ValueTask", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        sb.AppendLine("#endregion");
+    }
+}
@@ -0,0 +1,29 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Just.Railway.SourceGen.Executors.ResultExtensions.MainExtensions;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.ValueTaskExtensions;
+
+internal class ResultValueTaskTapExecutor : ResultTapExecutor
+{
+    protected override string NamespaceName => "Just.Railway.ValueTaskExtensions";
+    protected override string PartialClassName => "ResultValueTaskExtensions";
+
+    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);
+
+        sb.AppendLine($"#region {resultTypeDef}");
+
+        GenerateAsyncMethods("ValueTask", "ValueTask", sb, templateArgNames, resultTypeDef, resultValueExpansion);
+
+        sb.AppendLine("#endregion");
+    }
+}
@@ -0,0 +1,30 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Just.Railway.SourceGen.Executors.ResultExtensions.MainExtensions;
+
+namespace Just.Railway.SourceGen.Executors.ResultExtensions.ValueTaskExtensions;
+
+internal class ResultValueTaskTryRecoverExecutor : ResultTryRecoverExecutor
+{
+    protected override string NamespaceName => "Just.Railway.ValueTaskExtensions";
+    protected override string PartialClassName => "ResultValueTaskExtensions";
+
+
+    protected override void GenerateMethodsForArgCount(StringBuilder sb, int argCount)
+    {
+        if (argCount > 1) return;
+
+        var templateArgNames = Enumerable.Repeat("T", argCount)
+            .ToImmutableArray();
+
+        string methodTemplateDecl = GenerateTemplateDecl(templateArgNames);
+        string resultTypeDef = GenerateResultTypeDef(templateArgNames);
+
+        sb.AppendLine($"#region {resultTypeDef}");
+
+        GenerateAsyncMethods("ValueTask", "ValueTask", sb, templateArgNames, resultTypeDef, methodTemplateDecl);
+
+        sb.AppendLine("#endregion");
+    }
+}