added Extend extension methods generation

Railway.SourceGenerator/ExtensionsMethodGenerator.cs

@@ -13,6 +13,7 @@ public class ExtensionsMethodGenerator : IIncrementalGenerator
         new ResultMapExecutor(),
         new ResultBindExecutor(),
         new ResultTapExecutor(),
+        new ResultExtendExecutor(),
         new ResultTryRecoverExecutor(),
         new ResultAppendExecutor(),
         new TryExtensionsExecutor(),

Railway.SourceGenerator/ResultAppendExecutor.cs

@@ -460,12 +460,4 @@ internal sealed class ResultAppendExecutor : ResultExtensionsExecutor
         }
         """);
     }
-
-    internal static string JoinArguments(string arg1, string arg2) => (arg1, arg2) switch
-    {
-        ("", "") => "",
-        (string arg, "") => arg,
-        ("", string arg) => arg,
-        _ => $"{arg1}, {arg2}"
-    };
 }

Railway.SourceGenerator/ResultExtendExecutor.cs

@@ -0,0 +1,160 @@
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Microsoft.CodeAnalysis;
+
+namespace Just.Railway.SourceGen;
+
+internal sealed class ResultExtendExecutor : ResultExtensionsExecutor
+{
+    protected override string ExtensionType => "Extend";
+
+    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", 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 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{{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{{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{{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")}});
+        }
+        """);
+    }
+}

Railway.SourceGenerator/ResultExtensionsExecutor.cs

@@ -50,6 +50,13 @@ internal abstract class ResultExtensionsExecutor : IGeneratorExecutor
             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)
     {

Railway/Error.cs

@@ -52,7 +52,7 @@ public abstract class Error : IEquatable<Error>, IComparable<Error>
     [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Error Many(Error error1, Error error2) => (error1, error2) switch
     {
-        (null, null) => new ManyErrors(new List<Error>()),
+        (null, null) => new ManyErrors(ImmutableArray<Error>.Empty),
         (Error err, null) => err,
         (Error err, { IsEmpty: true }) => err,
         (null, Error err) => err,
@@ -137,12 +137,14 @@ public abstract class Error : IEquatable<Error>, IComparable<Error>
         return string.Compare(Message, other.Message);
     }
 
-    [Pure] public override string ToString() => Message;
+    [Pure] public sealed override string ToString() => Message;
     [Pure] public void Deconstruct(out string type, out string message)
     {
         type = Type;
         message = Message;
     }
+
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)] internal virtual Error AccessUnsafe(int position) => this;
 }
 
 [JsonConverter(typeof(ExpectedErrorJsonConverter))]
@@ -221,7 +223,7 @@ public sealed class ExceptionalError : Error
         if (!(exception.Data?.Count > 0))
         return ImmutableDictionary<string, string>.Empty;
 
-        List<KeyValuePair<string, string>>? values = null;
+        ImmutableDictionary<string, string>.Builder? values = null;
 
         foreach (var key in exception.Data.Keys)
         {
@@ -234,63 +236,70 @@ public sealed class ExceptionalError : Error
             var valueString = value.ToString();
             if (string.IsNullOrEmpty(keyString) || string.IsNullOrEmpty(valueString)) continue;
 
-            values ??= new List<KeyValuePair<string, string>>(4);
+            values ??= ImmutableDictionary.CreateBuilder<string, string>();
-            values.Add(new(keyString, valueString));
+            values.Add(keyString, valueString);
         }
-        return values?.ToImmutableDictionary() ?? ImmutableDictionary<string, string>.Empty;
+        return values is not null ? values.ToImmutable() : ImmutableDictionary<string, string>.Empty;
     }
 }
 
 [JsonConverter(typeof(ManyErrorsJsonConverter))]
 public sealed class ManyErrors : Error, IEnumerable<Error>, IReadOnlyList<Error>
 {
-    private readonly List<Error> _errors;
+    private readonly ImmutableArray<Error> _errors;
     [Pure] public IEnumerable<Error> Errors { get => _errors; }
 
-    internal ManyErrors(List<Error> errors) => _errors = errors;
+    internal ManyErrors(ImmutableArray<Error> errors) => _errors = errors;
     internal ManyErrors(Error head, Error tail)
     {
-        _errors = new List<Error>(head.Count + tail.Count);
+        var headCount = head.Count;
+        var tailCount = tail.Count;
+        var errors = ImmutableArray.CreateBuilder<Error>(headCount + tailCount);
 
-        if (head.Count == 1)
+        if (headCount > 0)
-            _errors.Add(head);
+            AppendSanitized(errors, head);
-        else if (head.Count > 1)
-            _errors.AddRange(head.ToEnumerable());
 
-        if (tail.Count == 1)
+        if (tailCount > 0)
-            _errors.Add(tail);
+            AppendSanitized(errors, tail);
-        else if (tail.Count > 1)
+
-            _errors.AddRange(tail.ToEnumerable());
+        _errors = errors.MoveToImmutable();
     }
     public ManyErrors(IEnumerable<Error> errors)
     {
-        _errors = errors.SelectMany(x => x.ToEnumerable())
+        var unpackedErrors = ImmutableArray.CreateBuilder<Error>();
-            .Where(x => !x.IsEmpty)
+
-            .ToList();
+        foreach (var err in errors)
+        {
+            if (err.IsEmpty) continue;
+
+            AppendSanitized(unpackedErrors, err);
+        }
+
+        _errors = unpackedErrors.ToImmutable();
     }
 
     [Pure] public override string Type => "many_errors";
-    [Pure] public override string Message => ToFullArrayString();
-    [Pure] public override string ToString() => ToFullArrayString();
 
-    [Pure] private string ToFullArrayString()
+    private string? _lazyMessage = null;
+    [Pure] public override string Message => _lazyMessage ??= ToFullArrayString(_errors);
+
+    [Pure] private static string ToFullArrayString(in ImmutableArray<Error> errors)
     {
         var separator = Environment.NewLine;
-        var lastIndex = _errors.Count - 1;
 
         var sb = new StringBuilder();
-        for (int i = 0; i < _errors.Count; i++)
+        for (int i = 0; i < errors.Length; i++)
         {
-            sb.Append(_errors[i]);
+            sb.Append(errors[i]);
-            if (i < lastIndex)
+            sb.Append(separator);
-                sb.Append(separator);
         }
+        sb.Remove(sb.Length - separator.Length, separator.Length);
 
         return sb.ToString();
     }
 
-    [Pure] public override int Count => _errors.Count;
+    [Pure] public override int Count => _errors.Length;
-    [Pure] public override bool IsEmpty => _errors.Count == 0;
+    [Pure] public override bool IsEmpty => _errors.IsEmpty;
     [Pure] public override bool IsExpected => _errors.All(static x => x.IsExpected);
     [Pure] public override bool IsExeptional => _errors.Any(static x => x.IsExeptional);
 
@@ -303,22 +312,19 @@ public sealed class ManyErrors : Error, IEnumerable<Error>, IReadOnlyList<Error>
     {
         if (other is null)
             return -1;
-        if (other.Count != _errors.Count)
+        if (other.Count != _errors.Length)
-            return _errors.Count.CompareTo(other.Count);
+            return _errors.Length.CompareTo(other.Count);
 
-        var compareResult = 0;
+        for (int i = 0; i < _errors.Length; i++)
-        int i = 0;
-        foreach (var otherErr in other.ToEnumerable())
         {
-            var thisErr = _errors[i++];
+            var compareResult = _errors[i].CompareTo(other.AccessUnsafe(i));
-            compareResult = thisErr.CompareTo(otherErr);
             if (compareResult != 0)
             {
                 return compareResult;
             }
         }
 
-        return compareResult;
+        return 0;
     }
     [Pure] public override bool IsSimilarTo([NotNullWhen(true)] Error? other)
     {
@@ -326,15 +332,13 @@ public sealed class ManyErrors : Error, IEnumerable<Error>, IReadOnlyList<Error>
         {
             return false;
         }
-        if (_errors.Count != other.Count)
+        if (_errors.Length != other.Count)
         {
             return false;
         }
-        int i = 0;
+        for (int i = 0; i < _errors.Length; i++)
-        foreach (var otherErr in other.ToEnumerable())
         {
-            var thisErr = _errors[i++];
+            if (!_errors[i].IsSimilarTo(other.AccessUnsafe(i)))
-            if (!thisErr.IsSimilarTo(otherErr))
             {
                 return false;
             }
@@ -347,36 +351,49 @@ public sealed class ManyErrors : Error, IEnumerable<Error>, IReadOnlyList<Error>
         {
             return false;
         }
-        if (_errors.Count != other.Count)
+        if (_errors.Length != other.Count)
         {
             return false;
         }
-        int i = 0;
+        for (int i = 0; i < _errors.Length; i++)
-        foreach (var otherErr in other.ToEnumerable())
         {
-            var thisErr = _errors[i++];
+            if (!_errors[i].Equals(other.AccessUnsafe(i)))
-            if (!thisErr.Equals(otherErr))
             {
                 return false;
             }
         }
         return true;
     }
-    [Pure] public override int GetHashCode()
+
+    private int? _lazyHashCode = null;
+    [Pure] public override int GetHashCode() => _lazyHashCode ??= CalcHashCode(_errors);
+    private static int CalcHashCode(in ImmutableArray<Error> errors)
     {
-        if (_errors.Count == 0)
+        if (errors.IsEmpty)
             return 0;
 
         var hash = new HashCode();
-        foreach (var err in _errors)
+        foreach (var err in errors)
         {
             hash.Add(err);
         }
         return hash.ToHashCode();
     }
 
-    [Pure] public IEnumerator<Error> GetEnumerator() => _errors.GetEnumerator();
+
-    [Pure] IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    [Pure] public ImmutableArray<Error>.Enumerator GetEnumerator() => _errors.GetEnumerator();
+    [Pure] IEnumerator<Error> IEnumerable<Error>.GetEnumerator() => Errors.GetEnumerator();
+    [Pure] IEnumerator IEnumerable.GetEnumerator() => Errors.GetEnumerator();
+
+    internal static void AppendSanitized(ImmutableArray<Error>.Builder errors, Error error)
+    {
+        if (error is ManyErrors many)
+            errors.AddRange(many._errors);
+        else
+            errors.Add(error);
+    }
+
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)] internal override Error AccessUnsafe(int position) => _errors[position];
 }
 
 [Serializable]

Railway/ErrorJsonConverter.cs

@@ -35,7 +35,7 @@ public sealed class ErrorJsonConverter : JsonConverter<Error>
 
     internal static ManyErrors ReadMany(ref Utf8JsonReader reader)
     {
-        List<Error> errors = new(4);
+        var errors = ImmutableArray.CreateBuilder<Error>();
         while (reader.Read())
         {
             if (reader.TokenType == JsonTokenType.StartObject)
@@ -43,7 +43,7 @@ public sealed class ErrorJsonConverter : JsonConverter<Error>
                 errors.Add(ToExpectedError(ReadOne(ref reader)));
             }
         }
-        return new ManyErrors(errors);
+        return new ManyErrors(errors.ToImmutable());
     }
     internal static ExpectedError ToExpectedError(in (string Type, string Message, ImmutableDictionary<string, string> ExtensionData) errorInfo)
         => new(errorInfo.Type, errorInfo.Message) { ExtensionData = errorInfo.ExtensionData };
@@ -84,7 +84,7 @@ public sealed class ErrorJsonConverter : JsonConverter<Error>
                     else if (!string.IsNullOrEmpty(propname))
                     {
                         extensionData ??= ImmutableDictionary.CreateBuilder<string, string>();
-                        extensionData.Add(propname, propvalue);
+                        extensionData[propname] = propvalue;
                     }
 
                     break;

Railway/Result.cs

@@ -7,7 +7,13 @@ internal enum ResultState : byte
 
 public readonly partial struct Result : IEquatable<Result>
 {
-    internal SuccessUnit Value => new();
+    [SuppressMessage("Performance", "CA1822:Mark members as static", Justification = "Simplified source generation")]
+    internal SuccessUnit Value
+    {
+        [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => new();
+    }
+
     internal readonly Error? Error;
     internal readonly ResultState State;
 
@@ -36,12 +42,18 @@ public readonly partial struct Result : IEquatable<Result>
     public static Result<(T1, T2, T3, T4, T5)> Success<T1, T2, T3, T4, T5>(T1 value1, T2 value2, T3 value3, T4 value4, T5 value5) => new((value1, value2, value3, value4, value5));
 
 
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Result Failure(string error) => Error.New(error ?? throw new ArgumentNullException(nameof(error)));
+
     [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Result Failure(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
 
     [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Result Failure(Exception exception) => new(Error.New(exception) ?? throw new ArgumentNullException(nameof(exception)));
 
+    [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static Result<T> Failure<T>(string error) => Error.New(error ?? throw new ArgumentNullException(nameof(error)));
+
     [Pure, MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Result<T> Failure<T>(Error error) => new(error ?? throw new ArgumentNullException(nameof(error)));
 
@@ -66,13 +78,13 @@ public readonly partial struct Result : IEquatable<Result>
     [Pure] public bool IsSuccess => Error is null;
     [Pure] public bool IsFailure => Error is not null;
 
-    [Pure] public bool Success([MaybeNullWhen(false)]out SuccessUnit? u, [MaybeNullWhen(true), NotNullWhen(false)]out Error? error)
+    [Pure] public bool TryGetValue([MaybeNullWhen(false)]out SuccessUnit? u, [MaybeNullWhen(true), NotNullWhen(false)]out Error? error)
     {
         switch (State)
         {
             case ResultState.Success:
                 u = new SuccessUnit();
-                error = default;
+                error = null;
                 return true;
 
             case ResultState.Error:
@@ -161,13 +173,13 @@ public readonly struct Result<T> : IEquatable<Result<T>>
     [Pure] public bool IsSuccess => State == ResultState.Success;
     [Pure] public bool IsFailure => State == ResultState.Error;
 
-    [Pure] public bool Success([MaybeNullWhen(false)]out T value, [MaybeNullWhen(true), NotNullWhen(false)]out Error? error)
+    [Pure] public bool TryGetValue([MaybeNullWhen(false)]out T value, [MaybeNullWhen(true), NotNullWhen(false)]out Error? error)
     {
         switch (State)
         {
             case ResultState.Success:
                 value = Value;
-                error = default;
+                error = null;
                 return true;
 
             case ResultState.Error:

Railway/ResultExtensions.cs

@@ -1,3 +1,5 @@
+using System.Collections.Immutable;
+
 namespace Just.Railway;
 
 public static partial class ResultExtensions
@@ -80,7 +82,7 @@ public static partial class ResultExtensions
 
     public static Result Merge(this IEnumerable<Result> results)
     {
-        List<Error>? errors = null;
+        ImmutableArray<Error>.Builder? errors = null;
         bool hasErrors = false;
 
         foreach (var result in results.OrderBy(x => x.State))
@@ -89,8 +91,8 @@ public static partial class ResultExtensions
             {
                 case ResultState.Error:
                     hasErrors = true;
-                    errors ??= new(4);
+                    errors ??= ImmutableArray.CreateBuilder<Error>();
-                    errors.Add(result.Error!);
+                    ManyErrors.AppendSanitized(errors, result.Error!);
                     break;
 
                 case ResultState.Success:
@@ -102,7 +104,7 @@ public static partial class ResultExtensions
         }
         afterLoop:
         return hasErrors
-            ? new(new ManyErrors(errors!))
+            ? new(new ManyErrors(errors!.ToImmutable()))
             : new(null);
     }
     public static async Task<Result> Merge(this IEnumerable<Task<Result>> tasks)
@@ -113,8 +115,8 @@ public static partial class ResultExtensions
 
     public static Result<IEnumerable<T>> Merge<T>(this IEnumerable<Result<T>> results)
     {
-        List<T>? values = null;
+        ImmutableList<T>.Builder? values = null;
-        List<Error>? errors = null;
+        ImmutableArray<Error>.Builder? errors = null;
         bool hasErrors = false;
 
         foreach (var result in results.OrderBy(x => x.State))
@@ -123,13 +125,13 @@ public static partial class ResultExtensions
             {
                 case ResultState.Error:
                     hasErrors = true;
-                    errors ??= new(4);
+                    errors ??= ImmutableArray.CreateBuilder<Error>();
-                    errors.Add(result.Error!);
+                    ManyErrors.AppendSanitized(errors, result.Error!);
                     break;
 
                 case ResultState.Success:
                     if (hasErrors) goto afterLoop;
-                    values ??= new(4);
+                    values ??= ImmutableList.CreateBuilder<T>();
                     values.Add(result.Value);
                     break;
                     
@@ -138,8 +140,8 @@ public static partial class ResultExtensions
         }
         afterLoop:
         return hasErrors
-            ? new(new ManyErrors(errors!))
+            ? new(new ManyErrors(errors!.ToImmutable()))
-            : new((IEnumerable<T>?)values ?? Array.Empty<T>());
+            : new(values is not null ? values.ToImmutable() : ImmutableList<T>.Empty);
     }
     public static async Task<Result<IEnumerable<T>>> Merge<T>(this IEnumerable<Task<Result<T>>> tasks)
     {

Raliway.Tests/Results/GeneralUsage.cs

@@ -169,4 +169,47 @@ public class GeneralUsage
         Assert.True(result.IsFailure);
         Assert.Equal(error, result.Error);
     }
+
+    [Fact]
+    public void WhenExtendingSuccessWithSuccess_ShouldReturnSuccess()
+    {
+        var success = Result.Success(1)
+            .Append("2");
+
+        var result = success
+            .Extend((i, s) => Result.Success($"{i} + {s}"));
+
+        Assert.True(result.IsSuccess);
+        Assert.Equal((1, "2", "1 + 2"), result.Value);
+    }
+
+    [Fact]
+    public void WhenExtendingFailureWithSuccess_ShouldNotEvaluateExtension()
+    {
+        var failure = Result.Success(1)
+            .Append(Result.Failure<string>("failure"));
+
+        var result = failure
+            .Extend((i, s) =>
+            {
+                Assert.Fail();
+                return Result.Success("");
+            });
+
+        Assert.True(result.IsFailure);
+        Assert.Equal(Error.New("failure"), result.Error);
+    }
+
+    [Fact]
+    public void WhenExtendingSuccessWithFailure_ShouldReturnFailure()
+    {
+        var success = Result.Success(1)
+            .Append("2");
+
+        var result = success
+            .Extend((i, s) => Result.Failure<string>("failure"));
+
+        Assert.True(result.IsFailure);
+        Assert.Equal(Error.New("failure"), result.Error);
+    }
 }