diff --git a/Maybe.UnitTest/ElseErrorForwardingTests.cs b/Maybe.UnitTest/ElseErrorForwardingTests.cs
new file mode 100644
index 0000000..04f0a6c
--- /dev/null
+++ b/Maybe.UnitTest/ElseErrorForwardingTests.cs
@@ -0,0 +1,210 @@
+using System;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Maybe;
+using Xunit;
+
+namespace Maybe.UnitTest;
+
+public class ElseErrorForwardingTests
+{
+    // Dummy error type used in tests. Must satisfy the "new()" constraint.
+    private sealed class DummyError : Error
+    {
+        public string? Info { get; }
+        public DummyError() { }
+        public DummyError(string? info) => Info = info;
+    }
+
+    [Fact]
+    public void Else_WithForwardedError_ReturnsSuccess_WhenSuccess()
+    {
+        var success = 42.MightBe<int, DummyError>();
+
+        var result = success.Else(new DummyError("fwd"));
+
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(42);
+    }
+
+    [Fact]
+    public void Else_WithForwardedError_ReplacesError_WhenError()
+    {
+        var original = new DummyError("orig").MightBe<bool, DummyError>();
+
+        var fwd = new DummyError("fwd");
+        var result = original.Else(fwd);
+
+        result.IsError.Should().BeTrue();
+        result.ErrorOrThrow().Should().BeSameAs(fwd);
+    }
+
+    [Fact]
+    public void Else_WithValueFallback_ReturnsFallback_WhenError()
+    {
+        var original = new DummyError("orig").MightBe<string, DummyError>();
+
+        var result = original.Else("fallback");
+
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be("fallback");
+    }
+
+    [Fact]
+    public void Else_WithValueFunc_UsesFunc_WhenError_And_NotInvoked_WhenSuccess()
+    {
+        var invoked = false;
+        Func<DummyError, string> func = e =>
+        {
+            invoked = true;
+            return $"wrapped:" + e.Info;
+        };
+
+        var success = "ok".MightBe<string, DummyError>();
+        success.Else(func).IsSuccess.Should().BeTrue();
+        invoked.Should().BeFalse();
+
+        invoked = false;
+        var error = new DummyError("orig").MightBe<string, DummyError>();
+        var result = error.Else(func);
+        invoked.Should().BeTrue();
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be("wrapped:orig");
+    }
+
+    [Fact]
+    public void Else_WithErrorFunc_TransformsError_WhenError_And_NotInvoked_WhenSuccess()
+    {
+        var invoked = false;
+        Func<DummyError, DummyError> func = e =>
+        {
+            invoked = true;
+            return new DummyError($"x:" + e.Info);
+        };
+
+        var success = 1.MightBe<int, DummyError>();
+        var s = success.Else(func);
+        s.IsSuccess.Should().BeTrue();
+        invoked.Should().BeFalse();
+
+        invoked = false;
+        var err = new DummyError("orig").MightBe<int, DummyError>();
+        var r = err.Else(func);
+        invoked.Should().BeTrue();
+        r.IsError.Should().BeTrue();
+        r.ErrorOrThrow().Info.Should().Be("x:orig");
+    }
+
+    [Fact]
+    public void Else_ValueFunc_Null_Throws()
+    {
+        var err = new DummyError("e").MightBe<int, DummyError>();
+        Action act = () => err.Else((Func<DummyError, int>)null!);
+        act.Should().Throw<ArgumentNullException>().WithParameterName("fallbackFunc");
+    }
+
+    [Fact]
+    public void Else_ErrorFunc_Null_Throws()
+    {
+        var err = new DummyError("e").MightBe<int, DummyError>();
+        Action act = () => err.Else((Func<DummyError, DummyError>)null!);
+        act.Should().Throw<ArgumentNullException>().WithParameterName("fallbackErrorFunc");
+    }
+
+    [Fact]
+    public async Task Else_Task_WithForwardedError_ReplacesError_WhenError()
+    {
+        Task<Maybe<int, DummyError>> task = Task.FromResult(new DummyError("orig").MightBe<int, DummyError>());
+
+        var forwarded = new DummyError("fwd");
+        var result = await task.Else(forwarded);
+
+        result.IsError.Should().BeTrue();
+        result.ErrorOrThrow().Should().BeSameAs(forwarded);
+    }
+
+    [Fact]
+    public async Task Else_Task_WithValueFunc_Works_WhenError_And_NotInvoked_WhenSuccess()
+    {
+        var invoked = false;
+        Func<DummyError, string> func = e =>
+        {
+            invoked = true;
+            return "val";
+        };
+
+        var sTask = Task.FromResult("ok".MightBe<string, DummyError>());
+        (await sTask.Else(func)).IsSuccess.Should().BeTrue();
+        invoked.Should().BeFalse();
+
+        invoked = false;
+        var eTask = Task.FromResult(new DummyError("e").MightBe<string, DummyError>());
+        var r = await eTask.Else(func);
+        invoked.Should().BeTrue();
+        r.IsSuccess.Should().BeTrue();
+        r.ValueOrThrow().Should().Be("val");
+    }
+
+    [Fact]
+    public async Task ElseAsync_WithAsyncValueFunc_UsesTransformedValue_WhenError()
+    {
+        var maybe = new DummyError("orig").MightBe<int, DummyError>();
+
+        var result = await maybe.ElseAsync(async e =>
+        {
+            await Task.Delay(1);
+            return 99;
+        });
+
+        result.IsSuccess.Should().BeTrue();
+        result.ValueOrThrow().Should().Be(99);
+    }
+
+    [Fact]
+    public async Task ElseAsync_WithAsyncErrorFunc_UsesTransformedError_WhenError()
+    {
+        var maybe = new DummyError("orig").MightBe<int, DummyError>();
+
+        var result = await maybe.ElseAsync(async e =>
+        {
+            await Task.Delay(1);
+            return new DummyError($"async:" + e.Info);
+        });
+
+        result.IsError.Should().BeTrue();
+        result.ErrorOrThrow().Info.Should().Be("async:orig");
+    }
+
+    [Fact]
+    public async Task ElseAsync_Task_WithAsyncErrorFunc_UsesTransformedError_WhenError()
+    {
+        var task = Task.FromResult(new DummyError("orig").MightBe<int, DummyError>());
+
+        var result = await task.ElseAsync(async e =>
+        {
+            await Task.Delay(1);
+            return new DummyError($"async:" + e.Info);
+        });
+
+        result.IsError.Should().BeTrue();
+        result.ErrorOrThrow().Info.Should().Be("async:orig");
+    }
+
+    [Fact]
+    public async Task ElseAsync_ValueFunc_Null_Throws()
+    {
+        var err = new DummyError("e").MightBe<int, DummyError>();
+        Func<DummyError, Task<int>> f = null!;
+        var act = async () => await err.ElseAsync(f);
+        await act.Should().ThrowAsync<ArgumentNullException>().WithParameterName("fallbackAsync");
+    }
+
+    [Fact]
+    public async Task ElseAsync_ErrorFunc_Null_Throws()
+    {
+        var err = new DummyError("e").MightBe<int, DummyError>();
+        Func<DummyError, Task<DummyError>> f = null!;
+        var act = async () => await err.ElseAsync(f);
+        await act.Should().ThrowAsync<ArgumentNullException>().WithParameterName("forwardedErrorAsync");
+    }
+}
\ No newline at end of file
diff --git a/Maybe/MaybeExtensions.Else.cs b/Maybe/MaybeExtensions.Else.cs
index 6920e29..ded7bd9 100644
--- a/Maybe/MaybeExtensions.Else.cs
+++ b/Maybe/MaybeExtensions.Else.cs
@@ -1,4 +1,4 @@
-namespace Maybe;
+namespace Maybe;
 
 /// <summary>
 /// Provides extension methods for exiting the Maybe context by providing a fallback value or function.
@@ -9,37 +9,107 @@ public static partial class MaybeExtensions
     #region Synchronous Else (with Sync Fallback)
 
     /// <summary>
-    /// Returns the success value or, if the Maybe is an error, the provided fallback value.
+    /// Returns the original success as-is; otherwise returns the provided <paramref name="fallbackValue"/>.
     /// </summary>
+    /// <remarks>
+    /// Note: passing null as <paramref name="fallbackValue"/> may be ambiguous when both TValue and TError
+    /// are reference types and other overloads exist. Prefer explicit casts or the delegate-based overloads.
+    /// </remarks>
+    /// <param name="maybe">The Maybe to evaluate.</param>
+    /// <param name="fallbackValue">The value to return if <paramref name="maybe"/> is an error.</param>
+    /// <typeparam name="TValue">The success value type.</typeparam>
+    /// <typeparam name="TError">The error type.</typeparam>
+    /// <returns>
+    /// A successful Maybe with the original value, or a successful Maybe with <paramref name="fallbackValue"/>.
+    /// </returns>
     public static Maybe<TValue, TError> Else<TValue, TError>(
         this in Maybe<TValue, TError> maybe,
         TValue fallbackValue)
         where TError : BaseError, new()
     {
         return maybe.IsSuccess
-            ? maybe.ValueOrThrow()
+            ? maybe
             : fallbackValue;
     }
 
     /// <summary>
-    /// Returns the success value or, if the Maybe is an error, the result of the provided fallback function.
+    /// Returns the original success as-is; otherwise replaces the original error with the provided <paramref name="forwardedError"/>.
     /// </summary>
+    /// <remarks>
+    /// Useful to adapt low-level errors to higher-level domain errors. The original error is discarded.
+    /// </remarks>
+    /// <param name="maybe">The Maybe to evaluate.</param>
+    /// <param name="forwardedError">The error to return if <paramref name="maybe"/> is an error.</param>
+    /// <typeparam name="TValue">The success value type.</typeparam>
+    /// <typeparam name="TError">The error type.</typeparam>
+    /// <returns>
+    /// A successful Maybe with the original value, or an error Maybe with <paramref name="forwardedError"/>.
+    /// </returns>
+    public static Maybe<TValue, TError> Else<TValue, TError>(
+        this in Maybe<TValue, TError> maybe,
+        TError forwardedError)
+        where TError : BaseError, new()
+    {
+        return maybe.IsSuccess
+            ? maybe
+            : forwardedError;
+    }
+
+    /// <summary>
+    /// Returns the original success as-is; otherwise returns the result of <paramref name="fallbackFunc"/> invoked with the original error.
+    /// </summary>
+    /// <remarks>
+    /// The function is not invoked if the Maybe is successful.
+    /// </remarks>
+    /// <param name="maybe">The Maybe to evaluate.</param>
+    /// <param name="fallbackFunc">The function that maps the original error to a fallback success value.</param>
+    /// <typeparam name="TValue">The success value type.</typeparam>
+    /// <typeparam name="TError">The error type.</typeparam>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="fallbackFunc"/> is null.</exception>
     public static Maybe<TValue, TError> Else<TValue, TError>(
         this in Maybe<TValue, TError> maybe,
         Func<TError, TValue> fallbackFunc)
         where TError : BaseError, new()
     {
+        if (fallbackFunc is null) throw new ArgumentNullException(nameof(fallbackFunc));
+
         return maybe.IsSuccess
-            ? maybe.ValueOrThrow()
+            ? maybe
             : fallbackFunc(maybe.ErrorOrThrow());
     }
 
+    /// <summary>
+    /// Returns the original success as-is; otherwise transforms the original error via <paramref name="fallbackErrorFunc"/>.
+    /// </summary>
+    /// <remarks>
+    /// The function is not invoked if the Maybe is successful.
+    /// </remarks>
+    /// <param name="maybe">The Maybe to evaluate.</param>
+    /// <param name="fallbackErrorFunc">The function that maps the original error to a new error to return.</param>
+    /// <typeparam name="TValue">The success value type.</typeparam>
+    /// <typeparam name="TError">The error type.</typeparam>
+    /// <returns>
+    /// A successful Maybe with the original value, or an error Maybe with the transformed error.
+    /// </returns>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="fallbackErrorFunc"/> is null.</exception>
+    public static Maybe<TValue, TError> Else<TValue, TError>(
+        this in Maybe<TValue, TError> maybe,
+        Func<TError, TError> fallbackErrorFunc)
+        where TError : BaseError, new()
+    {
+        if (fallbackErrorFunc is null) throw new ArgumentNullException(nameof(fallbackErrorFunc));
+
+        return maybe.IsSuccess
+            ? maybe
+            : fallbackErrorFunc(maybe.ErrorOrThrow());
+    }
+
     #endregion
 
     #region Asynchronous Else on Task<Maybe> (with Sync Fallback)
 
     /// <summary>
-    /// Asynchronously returns the success value or, if the Maybe is an error, the provided fallback value.
+    /// Asynchronously returns the original success as-is; otherwise returns the provided <paramref name="fallbackValue"/>.
     /// </summary>
     public static async Task<Maybe<TValue, TError>> Else<TValue, TError>(
         this Task<Maybe<TValue, TError>> maybeTask,
@@ -51,45 +121,112 @@ public static async Task<Maybe<TValue, TError>> Else<TValue, TError>(
     }
 
     /// <summary>
-    /// Asynchronously returns the success value or, if the Maybe is an error, the result of the provided fallback function.
+    /// Asynchronously returns the original success as-is; otherwise replaces the original error with <paramref name="forwardedError"/>.
     /// </summary>
+    public static async Task<Maybe<TValue, TError>> Else<TValue, TError>(
+        this Task<Maybe<TValue, TError>> maybeTask,
+        TError forwardedError)
+        where TError : BaseError, new()
+    {
+        var maybe = await maybeTask.ConfigureAwait(false);
+        return maybe.Else(forwardedError);
+    }
+
+    /// <summary>
+    /// Asynchronously returns the original success as-is; otherwise returns the result of <paramref name="fallbackFunc"/> invoked with the original error.
+    /// </summary>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="fallbackFunc"/> is null.</exception>
     public static async Task<Maybe<TValue, TError>> Else<TValue, TError>(
         this Task<Maybe<TValue, TError>> maybeTask,
         Func<TError, TValue> fallbackFunc)
         where TError : BaseError, new()
     {
+        if (fallbackFunc is null) throw new ArgumentNullException(nameof(fallbackFunc));
+
         var maybe = await maybeTask.ConfigureAwait(false);
         return maybe.Else(fallbackFunc);
     }
 
+    /// <summary>
+    /// Asynchronously returns the original success as-is; otherwise transforms the original error via <paramref name="fallbackErrorFunc"/>.
+    /// </summary>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="fallbackErrorFunc"/> is null.</exception>
+    public static async Task<Maybe<TValue, TError>> Else<TValue, TError>(
+        this Task<Maybe<TValue, TError>> maybeTask,
+        Func<TError, TError> fallbackErrorFunc)
+        where TError : BaseError, new()
+    {
+        if (fallbackErrorFunc is null) throw new ArgumentNullException(nameof(fallbackErrorFunc));
+
+        var maybe = await maybeTask.ConfigureAwait(false);
+        return maybe.Else(fallbackErrorFunc);
+    }
+
     #endregion
 
     #region Asynchronous ElseAsync (with Async Fallback)
 
     /// <summary>
-    /// Returns the success value or, if the Maybe is an error, asynchronously executes the fallback function and returns its result.
+    /// Returns the original success as-is; otherwise asynchronously executes <paramref name="fallbackAsync"/> and returns its result.
     /// </summary>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="fallbackAsync"/> is null.</exception>
     public static async Task<Maybe<TValue, TError>> ElseAsync<TValue, TError>(
         this Maybe<TValue, TError> maybe,
         Func<TError, Task<TValue>> fallbackAsync)
         where TError : BaseError, new()
     {
+        if (fallbackAsync is null) throw new ArgumentNullException(nameof(fallbackAsync));
+
         return maybe.IsSuccess
             ? maybe
             : await fallbackAsync(maybe.ErrorOrThrow());
     }
 
     /// <summary>
-    /// Asynchronously returns the success value or, if the Maybe is an error, asynchronously executes the fallback function and returns its result.
+    /// Returns the original success as-is; otherwise asynchronously transforms the original error via <paramref name="forwardedErrorAsync"/>.
     /// </summary>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="forwardedErrorAsync"/> is null.</exception>
+    public static async Task<Maybe<TValue, TError>> ElseAsync<TValue, TError>(
+        this Maybe<TValue, TError> maybe,
+        Func<TError, Task<TError>> forwardedErrorAsync)
+        where TError : BaseError, new()
+    {
+        if (forwardedErrorAsync is null) throw new ArgumentNullException(nameof(forwardedErrorAsync));
+
+        return maybe.IsSuccess
+            ? maybe
+            : await forwardedErrorAsync(maybe.ErrorOrThrow());
+    }
+
+    /// <summary>
+    /// Asynchronously returns the original success as-is; otherwise asynchronously executes <paramref name="fallbackAsync"/> and returns its result.
+    /// </summary>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="fallbackAsync"/> is null.</exception>
     public static async Task<Maybe<TValue, TError>> ElseAsync<TValue, TError>(
         this Task<Maybe<TValue, TError>> maybeTask,
         Func<TError, Task<TValue>> fallbackAsync)
         where TError : BaseError, new()
     {
+        if (fallbackAsync is null) throw new ArgumentNullException(nameof(fallbackAsync));
+
         var maybe = await maybeTask.ConfigureAwait(false);
         return await maybe.ElseAsync(fallbackAsync).ConfigureAwait(false);
     }
 
+    /// <summary>
+    /// Asynchronously returns the original success as-is; otherwise asynchronously transforms the original error via <paramref name="fallbackErrorAsync"/>.
+    /// </summary>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="fallbackErrorAsync"/> is null.</exception>
+    public static async Task<Maybe<TValue, TError>> ElseAsync<TValue, TError>(
+        this Task<Maybe<TValue, TError>> maybeTask,
+        Func<TError, Task<TError>> fallbackErrorAsync)
+        where TError : BaseError, new()
+    {
+        if (fallbackErrorAsync is null) throw new ArgumentNullException(nameof(fallbackErrorAsync));
+
+        var maybe = await maybeTask.ConfigureAwait(false);
+        return await maybe.ElseAsync(fallbackErrorAsync).ConfigureAwait(false);
+    }
+
     #endregion
-}
+}
\ No newline at end of file